Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Normal\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import gym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps=1e-10\n",
    "DTYPE = torch.float32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, state_size, action_size, is_continuous=False):\n",
    "        super().__init__()\n",
    "        self.is_continuous = is_continuous\n",
    "        \n",
    "        pi_model = nn.Sequential(\n",
    "            nn.Linear(state_size, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128,64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64,64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, action_size)\n",
    "        )\n",
    "        \n",
    "        value_model = nn.Sequential(\n",
    "            nn.Linear(state_size, 50),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(50, 50),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(50, 50),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(50, 1)\n",
    "        )\n",
    "        \n",
    "        self.pi = pi_model\n",
    "        self.ve = value_model\n",
    "        \n",
    "    def forward(self, x):\n",
    "        pass\n",
    "    \n",
    "    def getValue(self, x):\n",
    "        x = torch.tensor(x, dtype=DTYPE)\n",
    "        return self.ve(x)\n",
    "    \n",
    "    def getPi(self, x):\n",
    "        x = torch.tensor(x, dtype=DTYPE)\n",
    "        probs = self.pi(x)\n",
    "        return nn.Softmax(dim=-1)(probs) if not self.is_continuous else probs \n",
    "    \n",
    "    def setContinuous(self):\n",
    "        self.is_continuous = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer():\n",
    "    def __init__(self, minl, maxl,alpha,sample_size=400):\n",
    "        self.max_length = maxl\n",
    "        self.length = 0\n",
    "        self.buffer = []\n",
    "        self.weights = []\n",
    "        self.alpha = alpha\n",
    "        self.min_length = minl\n",
    "        self.sample_size = sample_size\n",
    "        \n",
    "    def add(self, ep):\n",
    "        \n",
    "        weight = np.exp(self.alpha*np.array(ep['rewards']).sum())+eps\n",
    "#         if self.length>0 and weight < 0.75*np.min(self.weights) + 0.25 * np.mean(self.weights) and self.trainable(): return\n",
    "\n",
    "        self.buffer.append(ep)\n",
    "        self.length += 1\n",
    "\n",
    "        self.weights.append(weight)\n",
    "        \n",
    "        if self.length > self.max_length:\n",
    "            wts = np.array(self.weights)\n",
    "            idx = np.random.choice(self.length, p=1-wts/wts.sum())\n",
    "            del self.buffer[idx]\n",
    "            del self.weights[idx]\n",
    "            self.length-=1\n",
    "            \n",
    "    def sample(self):\n",
    "        wts = np.array(self.weights)\n",
    "        \n",
    "        sample_size = min(self.sample_size, self.length)\n",
    "        sample = np.random.choice(self.buffer,size=(sample_size,), p=wts/wts.sum(), replace=False)\n",
    "        out = sample if self.length>1 else [sample]\n",
    "        return out\n",
    "    \n",
    "    def trainable(self):\n",
    "        return self.length>self.min_length\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PCL(object):\n",
    "    def __init__(self, env, replay_buffer, state_size, action_size, epoch=1000, off_policy_rate=20, pi_lr=7e-4, \n",
    "                 ve_lr=3.5e-4, entropy_tau=0.15, rollout_d=20, gamma=1):\n",
    "        self.epoch = epoch\n",
    "        self.state_size =  state_size\n",
    "        self.action_size = action_size\n",
    "        self.net = Net(self.state_size, self.action_size)\n",
    "        self.net.is_continuous = False\n",
    "        \n",
    "        self.replay_buffer = replay_buffer\n",
    "        self.env = env\n",
    "        \n",
    "        self.pi_optimiser = optim.Adam(self.net.pi.parameters(), lr=pi_lr)\n",
    "        self.ve_optimiser = optim.Adam(self.net.ve.parameters(), lr=ve_lr)\n",
    "        self.off_policy_rate = off_policy_rate\n",
    "        self.tau = entropy_tau\n",
    "        self.rollout_d = rollout_d\n",
    "        self.gamma = gamma\n",
    "    \n",
    "    def selectProb(self, pi, a):\n",
    "        a = np.eye(self.action_size, dtype=np.int32)[a]\n",
    "        pi_selected = torch.sum(pi * torch.tensor(a, dtype=DTYPE), dim=1)\n",
    "        return torch.log(pi_selected+eps)\n",
    "\n",
    "        \n",
    "    def optimise(self, episodes):\n",
    "        net = self.net\n",
    "        \n",
    "        self.pi_optimiser.zero_grad()\n",
    "        self.ve_optimiser.zero_grad()\n",
    "        \n",
    "#         print(\"before loop\", episodes)\n",
    "        for episode in episodes:\n",
    "            rollout_d = min(self.rollout_d, len(episode['states']))\n",
    "            ma = len(episode['states'])-rollout_d+1\n",
    "            \n",
    "            for i in range(ma):\n",
    "                states = episode['states'][i:i+rollout_d]\n",
    "                a = episode['actions'][i:i+rollout_d]  \n",
    "                R = episode['rewards'][i:i+rollout_d]\n",
    "\n",
    "                ve_init = net.getValue(states[0])\n",
    "                ve_end = net.getValue(states[-1])\n",
    "\n",
    "                pi_all_states = net.getPi(states).squeeze(0)\n",
    "                log_pi_selected = self.selectProb(pi_all_states, a)\n",
    "\n",
    "                discount = torch.tensor(self.gamma**np.arange(0,rollout_d))\n",
    "\n",
    "                c = -ve_init + self.gamma**rollout_d*ve_end\\\n",
    "                + torch.sum(discount*(torch.tensor(R) - self.tau*log_pi_selected))\n",
    "\n",
    "                loss = c**2\n",
    "                loss.backward()\n",
    "                \n",
    "#                 print(\"----------------------------\", loss)\n",
    "#         print(\"after loop\")\n",
    "        \n",
    "        self.ve_optimiser.step()\n",
    "        self.pi_optimiser.step()\n",
    "        \n",
    "    def getStateEnc(self,x):\n",
    "        return x\n",
    "    def getStateDec(self,x):\n",
    "        return x\n",
    "    def getActionEnc(self,a):\n",
    "        return a\n",
    "    def getActionDec(self,a):\n",
    "        return a\n",
    "    \n",
    "    def getAction(self, state):\n",
    "        enc_state = self.getStateEnc(state)\n",
    "        \n",
    "        pi = self.net.getPi(enc_state).squeeze(0).detach().numpy()\n",
    "        return self.getActionDec(np.random.choice(np.arange(self.action_size), p=pi))\n",
    "    \n",
    "    def rollout(self, max_ep_length = -1):\n",
    "        states = []\n",
    "        actions = []\n",
    "        rewards = []\n",
    "        env = self.env\n",
    "        \n",
    "        state = env.reset()\n",
    "        is_terminated = False\n",
    "        timestep = 0\n",
    "        \n",
    "        while not is_terminated and timestep!=max_ep_length:\n",
    "            action = self.getAction(state)\n",
    "            next_state, reward, is_terminated, _ = env.step(action)\n",
    "            \n",
    "            states.append(self.getStateEnc(state))\n",
    "            actions.append(self.getActionEnc(action))\n",
    "            rewards.append(reward)\n",
    "            \n",
    "            state = next_state\n",
    "            timestep += 1\n",
    "\n",
    "        \n",
    "        rewards = np.array(rewards)\n",
    "#         print(np.mean(rewards))\n",
    "#         rewards = (rewards - np.mean(rewards))\n",
    "        \n",
    "#         print(len(states))\n",
    "#         print(\"\")\n",
    "        return dict(\n",
    "            states = states,\n",
    "            actions = actions,\n",
    "            rewards = list(rewards)\n",
    "        )\n",
    "    \n",
    "    def train(self, max_ep_length=-1):\n",
    "        tot_rewards = []\n",
    "        mean_ep_reward = []\n",
    "        fig = plt.figure()\n",
    "        \n",
    "        means = []\n",
    "        ma = []\n",
    "        mi = []\n",
    "        \n",
    "        for i in range(self.epoch):\n",
    "            episode = self.rollout(max_ep_length)        \n",
    "            self.optimise([episode])\n",
    "            \n",
    "            r = np.array(episode['rewards'])\n",
    "            \n",
    "            self.replay_buffer.add(episode)\n",
    "            \n",
    "            ########off policy\n",
    "            if self.replay_buffer.trainable():\n",
    "                for _ in range(self.off_policy_rate):\n",
    "                    episodes = self.replay_buffer.sample()\n",
    "                    self.optimise(episodes)\n",
    "            \n",
    "            \n",
    "            tot_rewards.append(r.sum())\n",
    "            mean_ep_reward.append(r.mean())\n",
    "            \n",
    "            if i>10: \n",
    "                print(\"I: {},    B:{}       R: {}                    \".format(i, self.replay_buffer.length, np.mean(tot_rewards[-10:])), end='\\r')\n",
    "            else:\n",
    "                print(\"I: {},    B:{}       R: {}                    \".format(i, self.replay_buffer.length, tot_rewards[-1]), end='\\r')\n",
    "                continue\n",
    "            \n",
    "            fig.clf()\n",
    "\n",
    "            means.append(np.array(tot_rewards)[-10:].mean())\n",
    "            plt.plot(np.arange(len(means)), np.array(means), c='r')\n",
    "\n",
    "            mi.append(np.array(tot_rewards)[-10:].min())\n",
    "            ma.append(np.array(tot_rewards)[-10:].max())\n",
    "            plt.fill_between(np.arange(len(means)), mi, ma, color='r', alpha=0.5)\n",
    "\n",
    "            fig.canvas.draw()\n",
    "            \n",
    "        return mean_ep_reward, tot_rewards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContinuousPCL(PCL):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        self.net.setContinuous()\n",
    "        \n",
    "    def selectProb(self, params, a):\n",
    "        \"\"\"\n",
    "        params: [mean, var]\n",
    "        \"\"\"\n",
    "        \n",
    "        mean = params[:, 0]\n",
    "        std = params[:, 1]\n",
    "        a = torch.tensor(a, dtype=DTYPE)\n",
    "        \n",
    "        return -(a-mean)**2/(std**2+eps) - std  \n",
    "    \n",
    "    def getAction(self, state):\n",
    "        enc_state = self.getStateEnc(state)\n",
    "        params = self.net.getPi(enc_state).squeeze(0).detach()\n",
    "        action = Normal(params[0], params[1]).sample().numpy()\n",
    "        return np.array([action])\n",
    "    \n",
    "    def getActionEnc(self, action):\n",
    "        return torch.tensor(action, dtype=DTYPE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CopyPCL(PCL):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "    \n",
    "    def getStateEnc(self,x):\n",
    "        return np.array([x])\n",
    "    \n",
    "    def getStateDec(self,x):\n",
    "        return x[0]\n",
    "    \n",
    "    def getActionEnc(self,a):\n",
    "        return a[0]*6 +(1-a[1])*5+ a[2]\n",
    "    \n",
    "    def getActionDec(self,a):\n",
    "        return (a//6, 1-(a%6)//5, (a%6)%5)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "env = gym.make('Copy-v0')\n",
    "buffer = ReplayBuffer(32, 10000, 1, sample_size=400)\n",
    "agent = CopyPCL(env, buffer, 1, 12, epoch=100000, off_policy_rate=5,entropy_tau=0.05, pi_lr=0.005, ve_lr=0.0025)\n",
    "# agent.getStateEnc = lambda x: np.eye(6)[int(x)]\n",
    "# agent.getStateDec = lambda x: np.argmax(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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=\"639.4833333333333\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I: 176,    B:177       R: 0.85                    \r"
     ]
    }
   ],
   "source": [
    "a = agent.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 3)"
      ]
     },
     "execution_count": 372,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent.getAction(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rl",
   "language": "python",
   "name": "rl"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}