pvc-actor-critic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nengo\n",
    "# import nengo_ocl\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import gym\n",
    "from nengo.utils.matplotlib import rasterplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nolandey/anaconda/envs/tensorflow3/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
     ]
    },
    {
     "data": {
      "application/vdom.v1+json": {
       "attributes": {},
       "tagName": "div"
      },
      "text/html": [
       "\n",
       "                <script>\n",
       "                    if (Jupyter.version.split(\".\")[0] < 5) {\n",
       "                        var pb = document.getElementById(\"55bf88bf-23bc-4746-985f-8c7c54973ba8\");\n",
       "                        var text = document.createTextNode(\n",
       "                            \"HMTL progress bar requires Jupyter Notebook >= \" +\n",
       "                            \"5.0 or Jupyter Lab. Alternatively, you can use \" +\n",
       "                            \"TerminalProgressBar().\");\n",
       "                        pb.parentNode.insertBefore(text, pb);\n",
       "                    }\n",
       "                </script>\n",
       "                <div id=\"55bf88bf-23bc-4746-985f-8c7c54973ba8\" style=\"\n",
       "                    width: 100%;\n",
       "                    border: 1px solid #cfcfcf;\n",
       "                    border-radius: 4px;\n",
       "                    text-align: center;\n",
       "                    position: relative;\">\n",
       "                  <div class=\"pb-text\" style=\"\n",
       "                      position: absolute;\n",
       "                      width: 100%;\">\n",
       "                    0%\n",
       "                  </div>\n",
       "                  <div class=\"pb-fill\" style=\"\n",
       "                      background-color: #bdd2e6;\n",
       "                      width: 0%;\">\n",
       "                    <style type=\"text/css\" scoped=\"scoped\">\n",
       "                        @keyframes pb-fill-anim {\n",
       "                            0% { background-position: 0 0; }\n",
       "                            100% { background-position: 100px 0; }\n",
       "                        }\n",
       "                    </style>\n",
       "                    &nbsp;\n",
       "                  </div>\n",
       "                </div>"
      ],
      "text/plain": [
       "HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vdom.v1+json": {
       "attributes": {
        "id": "df0c6cd0-fabf-4f64-9932-b349b3e6d764",
        "style": {
         "border": "1px solid #cfcfcf",
         "borderRadius": "4px",
         "boxSizing": "border-box",
         "position": "relative",
         "textAlign": "center",
         "width": "100%"
        }
       },
       "children": [
        {
         "attributes": {
          "class": "pb-text",
          "style": {
           "position": "absolute",
           "width": "100%"
          }
         },
         "children": [
          "Build finished in 0:00:01."
         ],
         "tagName": "div"
        },
        {
         "attributes": {
          "class": "pb-fill",
          "style": {
           "animation": "none",
           "backgroundColor": "#bdd2e6",
           "backgroundImage": "none",
           "backgroundSize": "100px 100%",
           "width": "100%"
          }
         },
         "children": [
          {
           "attributes": {
            "scoped": "scoped",
            "type": "text/css"
           },
           "children": [
            "\n                        @keyframes pb-fill-anim {\n                            0% { background-position: 0 0; }\n                            100% { background-position: 100px 0; }\n                        }}"
           ],
           "tagName": "style"
          },
          " "
         ],
         "tagName": "div"
        }
       ],
       "tagName": "div"
      },
      "text/html": [
       "<script>\n",
       "              (function () {\n",
       "                  var root = document.getElementById('55bf88bf-23bc-4746-985f-8c7c54973ba8');\n",
       "                  var text = root.getElementsByClassName('pb-text')[0];\n",
       "                  var fill = root.getElementsByClassName('pb-fill')[0];\n",
       "\n",
       "                  text.innerHTML = 'Build finished in 0:00:01.';\n",
       "                  \n",
       "            fill.style.width = '100%';\n",
       "            fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
       "            fill.style.backgroundSize = '100px 100%';\n",
       "            fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
       "                '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
       "        \n",
       "                  \n",
       "                fill.style.animation = 'none';\n",
       "                fill.style.backgroundImage = 'none';\n",
       "            \n",
       "              })();\n",
       "        </script>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vdom.v1+json": {
       "attributes": {},
       "tagName": "div"
      },
      "text/html": [
       "\n",
       "                <script>\n",
       "                    if (Jupyter.version.split(\".\")[0] < 5) {\n",
       "                        var pb = document.getElementById(\"499b3ce5-dc14-4ed0-8a89-26d8feab3146\");\n",
       "                        var text = document.createTextNode(\n",
       "                            \"HMTL progress bar requires Jupyter Notebook >= \" +\n",
       "                            \"5.0 or Jupyter Lab. Alternatively, you can use \" +\n",
       "                            \"TerminalProgressBar().\");\n",
       "                        pb.parentNode.insertBefore(text, pb);\n",
       "                    }\n",
       "                </script>\n",
       "                <div id=\"499b3ce5-dc14-4ed0-8a89-26d8feab3146\" style=\"\n",
       "                    width: 100%;\n",
       "                    border: 1px solid #cfcfcf;\n",
       "                    border-radius: 4px;\n",
       "                    text-align: center;\n",
       "                    position: relative;\">\n",
       "                  <div class=\"pb-text\" style=\"\n",
       "                      position: absolute;\n",
       "                      width: 100%;\">\n",
       "                    0%\n",
       "                  </div>\n",
       "                  <div class=\"pb-fill\" style=\"\n",
       "                      background-color: #bdd2e6;\n",
       "                      width: 0%;\">\n",
       "                    <style type=\"text/css\" scoped=\"scoped\">\n",
       "                        @keyframes pb-fill-anim {\n",
       "                            0% { background-position: 0 0; }\n",
       "                            100% { background-position: 100px 0; }\n",
       "                        }\n",
       "                    </style>\n",
       "                    &nbsp;\n",
       "                  </div>\n",
       "                </div>"
      ],
      "text/plain": [
       "HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vdom.v1+json": {
       "attributes": {
        "id": "cafcea3b-c7ce-4ff2-8ee8-5f1fbc59f5c7",
        "style": {
         "border": "1px solid #cfcfcf",
         "borderRadius": "4px",
         "boxSizing": "border-box",
         "position": "relative",
         "textAlign": "center",
         "width": "100%"
        }
       },
       "children": [
        {
         "attributes": {
          "class": "pb-text",
          "style": {
           "position": "absolute",
           "width": "100%"
          }
         },
         "children": [
          "Simulating… 3%, ETA: 8:26:07"
         ],
         "tagName": "div"
        },
        {
         "attributes": {
          "class": "pb-fill",
          "style": {
           "animation": "none",
           "backgroundColor": "#bdd2e6",
           "backgroundImage": "none",
           "transition": "width 0.1s linear",
           "width": "3%"
          }
         },
         "children": [
          {
           "attributes": {
            "scoped": "scoped",
            "type": "text/css"
           },
           "children": [
            "\n                        @keyframes pb-fill-anim {\n                            0% { background-position: 0 0; }\n                            100% { background-position: 100px 0; }\n                        }}"
           ],
           "tagName": "style"
          },
          " "
         ],
         "tagName": "div"
        }
       ],
       "tagName": "div"
      },
      "text/html": [
       "<script>\n",
       "              (function () {\n",
       "                  var root = document.getElementById('499b3ce5-dc14-4ed0-8a89-26d8feab3146');\n",
       "                  var text = root.getElementsByClassName('pb-text')[0];\n",
       "                  var fill = root.getElementsByClassName('pb-fill')[0];\n",
       "\n",
       "                  text.innerHTML = 'Simulating&hellip; 3%, ETA: 8:26:07';\n",
       "                  \n",
       "            if (3.3439916666666667 > 0.) {\n",
       "                fill.style.transition = 'width 0.1s linear';\n",
       "            } else {\n",
       "                fill.style.transition = 'none';\n",
       "            }\n",
       "\n",
       "            fill.style.width = '3.3439916666666667%';\n",
       "            fill.style.animation = 'none';\n",
       "            fill.style.backgroundImage = 'none'\n",
       "        \n",
       "                  \n",
       "              })();\n",
       "        </script>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "\n",
    "# master class that performs environment interaction and learning\n",
    "class Master():\n",
    "    def __init__(self,\n",
    "                 env_name,\n",
    "                 n_actor,\n",
    "                 n_critic,\n",
    "                 n_place,\n",
    "                 dt,\n",
    "                 V_0,\n",
    "                 v,\n",
    "                 tau_r,\n",
    "                 stepSize=1,\n",
    "                 actor_lr=0.05,\n",
    "                 critic_lr=0.2):\n",
    "        \n",
    "        # gym\n",
    "        self.env = gym.make(env_name)\n",
    "        self.env.seed(0)\n",
    "        if type(self.env.action_space) == gym.spaces.discrete.Discrete:\n",
    "            self.action_dim = self.env.action_space.n\n",
    "            self.discrete_actions = True\n",
    "        else:\n",
    "            self.action_dim = self.env.action_space.shape[0]\n",
    "            self.discrete_actions = False\n",
    "            \n",
    "        if env_name == 'Pendulum-v0':\n",
    "            self.F_max = 2\n",
    "            self.actor_directions = 2 * self.F_max * np.arange(n_actor) / n_actor - self.F_max\n",
    "            self.min_reward = -16.2736044\n",
    "        \n",
    "        self.state_dim = self.env.observation_space.shape[0]\n",
    "        self.stepsize = stepSize\n",
    "        self.dt = dt\n",
    "        self.state = self.env.reset()\n",
    "        self.reward = 0\n",
    "        self.done = False\n",
    "        self.reward_history = []\n",
    "        self.totalReward = 0\n",
    "        self.max_steps = 50\n",
    "        self.step_num = 0\n",
    "        \n",
    "        self.V_0 = V_0\n",
    "        self.v = v\n",
    "        self.tau_r = tau_r\n",
    "        self.actor_lr = actor_lr\n",
    "        self.critic_lr = critic_lr\n",
    "        self.place_actor_weights = np.load('cache/place_actor_weights.npy')\n",
    "        self.place_critic_weights = np.load('cache/place_critic_weights.npy')\n",
    "#         self.place_actor_weights = np.random.normal(loc=0.5, scale=0.1, size=(n_actor, n_place))\n",
    "#         self.place_critic_weights = np.random.normal(loc=0.5, scale=0.1, size=(n_critic, n_place))\n",
    "        self.w_min = 0\n",
    "        self.w_max = 3\n",
    "    \n",
    "    def step(self, t, action):\n",
    "        if int(t / self.dt) % self.stepsize != 0:\n",
    "            return\n",
    "        self.step_num += 1\n",
    "#         self.env.render()\n",
    "        self.state, self.reward, self.done, _ = self.env.step(action)\n",
    "        self.totalReward += self.reward\n",
    "        if self.step_num == self.max_steps:\n",
    "#             self.reward = -2 # penalize end of episode\n",
    "            self.totalReward += self.reward\n",
    "            self.reward_history.append(self.totalReward)\n",
    "            self.state = self.env.reset()\n",
    "            self.totalReward = 0\n",
    "            self.step_num = 0\n",
    "\n",
    "    def sensor(self,t):\n",
    "        return self.state\n",
    "            \n",
    "    def calc_td_error(self, t, critic_rates):\n",
    "#         print('td', critic_rates)\n",
    "        return self.v * np.mean(critic_rates*self.dt) - self.V_0/self.tau_r + self.reward\n",
    "\n",
    "    def outer(self, t, x):\n",
    "        X_conv_eps = x[:n_place]* self.dt\n",
    "        Y = x[n_place:]* self.dt\n",
    "#         print('outer', X_conv_eps, Y)\n",
    "        return np.outer(Y, X_conv_eps).flatten()\n",
    "    \n",
    "    def actor(self, t, x):\n",
    "        dVdw = x[:n_place * n_actor].reshape(n_actor, n_place)\n",
    "        place_spikes = x[n_place * n_actor:-1] * self.dt\n",
    "        td_error = x[-1]\n",
    "        self.place_actor_weights += self.actor_lr * td_error * dVdw\n",
    "        self.place_actor_weights = np.clip(self.place_actor_weights, a_min=self.w_min, a_max=self.w_max)\n",
    "#         print('actor', np.dot(self.place_actor_weights, place_spikes))\n",
    "#         print('actor', self.place_actor_weights, place_spikes)\n",
    "        return np.dot(self.place_actor_weights, place_spikes)\n",
    "        \n",
    "    def critic(self, t, x):\n",
    "        dVdw = x[:n_place * n_critic].reshape(n_critic, n_place)\n",
    "        place_spikes = x[n_place * n_critic:-1] * self.dt\n",
    "        td_error = x[-1]\n",
    "        self.place_critic_weights += self.critic_lr * td_error * dVdw\n",
    "        self.place_critic_weights = np.clip(self.place_critic_weights, a_min=self.w_min, a_max=self.w_max)\n",
    "        \n",
    "        return np.dot(self.place_critic_weights, place_spikes)\n",
    "\n",
    "    def select_action(self, t, actor_rates):\n",
    "#         return self.actor_directions[np.argmax(actor_rates)]\n",
    "#         print(actor_rates)\n",
    "        rate_sum = np.sum(actor_rates*self.dt)\n",
    "        if rate_sum == 0: return 0\n",
    "        return np.dot(actor_rates*self.dt, self.actor_directions) / rate_sum\n",
    "    \n",
    "    def calc_value(self, t, critic_rates):\n",
    "        return self.v * np.mean(critic_rates*self.dt) + self.V_0\n",
    "    \n",
    "# v = 2\n",
    "# V_0 = -40\n",
    "V_0 = -16\n",
    "v = 30\n",
    "tau_r = 4 # reward time constant\n",
    "v_k = 50e-3\n",
    "tau_k = 200e-3\n",
    "eps_0 = 20e-3\n",
    "tau_m = 20e-3\n",
    "tau_s = 5e-3\n",
    "tau_gamma = 50e-3\n",
    "v_gamma = 20e-3\n",
    "\n",
    "dt = 1e-3\n",
    "n_actor = 40\n",
    "n_critic = 50\n",
    "n_place = 600\n",
    "place_radius = 5\n",
    "actor_radius = 2\n",
    "critic_radius = 8\n",
    "\n",
    "stepSize = 50\n",
    "actor_lr = 0.05\n",
    "critic_lr = 0.2\n",
    "\n",
    "lateral_sigma = 3\n",
    "lateral_inhibition = 0.1\n",
    "\n",
    "actor_lambda = 0.5\n",
    "w_plus = 30\n",
    "w_minus = -60\n",
    "lateral_stability_const = (n_actor/actor_lambda/2)**2\n",
    "\n",
    "# env_name = 'CartPole-v0'\n",
    "# env_name = 'MountainCarContinuous-v0'\n",
    "env_name = 'Pendulum-v0'\n",
    "master = Master(\n",
    "    env_name=env_name,\n",
    "    n_actor=n_actor,\n",
    "    n_critic=n_critic,\n",
    "    n_place=n_place,\n",
    "    dt=dt,\n",
    "    V_0=V_0,\n",
    "    v=v,\n",
    "    tau_r=tau_r,\n",
    "    stepSize=stepSize,\n",
    "    actor_lr=actor_lr,\n",
    "    critic_lr=critic_lr\n",
    ")\n",
    "model = nengo.Network(seed=0)\n",
    "\n",
    "\n",
    "with model:\n",
    "    state_node = nengo.Node(output=master.sensor)\n",
    "    place = nengo.Ensemble(n_neurons=n_place,\n",
    "                           dimensions=master.state_dim,\n",
    "                           radius=place_radius)\n",
    "    nengo.Connection(state_node, place)\n",
    "    \n",
    "    #####################################################\n",
    "    \n",
    "    actor = nengo.Ensemble(n_neurons=n_actor,\n",
    "                           dimensions=master.action_dim,\n",
    "                           radius=actor_radius)\n",
    "    \n",
    "    \n",
    "#     paper lateral actor connections\n",
    "#     lateral_weight_denom = 2*np.sum([\n",
    "#         np.exp((k/actor_lambda)**2 - lateral_stability_const)\n",
    "#         for k in range(1, int(n_actor/2))\n",
    "#     ])\n",
    "#     print('d',lateral_weight_denom)\n",
    "#     for k in range(n_actor):\n",
    "#         for k_p in range(n_actor):\n",
    "#             if k == k_p: continue\n",
    "#             lateral_weight = w_minus/n_actor \\\n",
    "#                 + w_plus * np.exp(((k - k_p)/actor_lambda)**2 - lateral_stability_const) / lateral_weight_denom\n",
    "#             print('w',lateral_weight)\n",
    "#             if lateral_weight == 0: continue\n",
    "#             nengo.Connection(actor.neurons[k],\n",
    "#                              actor.neurons[k_p],\n",
    "#                              transform=[lateral_weight])\n",
    "    \n",
    "#   gaussian lateral actor connections\n",
    "    lateral_weights = np.zeros((n_actor, n_actor))\n",
    "    for k in range(n_actor):\n",
    "        for k_p in range(n_actor):\n",
    "            if k == k_p: continue # no self connection\n",
    "            lateral_weight = (1+lateral_inhibition)*np.exp(-((k - k_p)/lateral_sigma)**2) - lateral_inhibition\n",
    "            lateral_weights[k,k_p] = lateral_weight\n",
    "    nengo.Connection(actor.neurons, actor.neurons, transform=lateral_weights)\n",
    "    \n",
    "    actor_outer = nengo.Node(master.outer,\n",
    "                            size_in=n_place + n_actor,\n",
    "                            size_out=n_place * n_actor)\n",
    "    # convolve place spikes with epsilon\n",
    "    nengo.Connection(place.neurons,\n",
    "                     actor_outer[:n_place],\n",
    "                     synapse=tau_m,\n",
    "                     transform=((eps_0 * tau_m) / (tau_m - tau_s)))\n",
    "    nengo.Connection(place.neurons,\n",
    "                     actor_outer[:n_place],\n",
    "                     synapse=tau_s,\n",
    "                     transform=-((eps_0 * tau_s) / (tau_m - tau_s)))\n",
    "    # Pass raw actor spikes into actor_outer\n",
    "    nengo.Connection(actor.neurons, actor_outer[n_place:], synapse=None)\n",
    "                     \n",
    "    actor_learn = nengo.Node(master.actor,\n",
    "                            size_in=n_place * n_actor + n_place + 1,\n",
    "                            size_out=n_actor)\n",
    "    # convolve actor_outer output with k / tau_r\n",
    "    nengo.Connection(actor_outer, \n",
    "                     actor_learn[:n_place * n_actor], \n",
    "                     synapse=tau_k,\n",
    "                     transform=tau_k/((tau_k - v_k)*tau_r))\n",
    "    nengo.Connection(actor_outer, \n",
    "                     actor_learn[:n_place * n_actor], \n",
    "                     synapse=v_k,\n",
    "                     transform=(-v_k)/((tau_k - v_k)*tau_r))\n",
    "    # Pass convolved place spikes with epsilon into actor_learn\n",
    "    nengo.Connection(place.neurons,\n",
    "                     actor_learn[n_place * n_actor:-1],\n",
    "                     synapse=tau_m,\n",
    "                     transform=((eps_0 * tau_m) / (tau_m - tau_s)))\n",
    "    nengo.Connection(place.neurons,\n",
    "                     actor_learn[n_place * n_actor:-1],\n",
    "                     synapse=tau_s,\n",
    "                     transform=-((eps_0 * tau_s) / (tau_m - tau_s)))\n",
    "    \n",
    "    # connect actor_learn to actor neurons\n",
    "    nengo.Connection(actor_learn, actor.neurons, synapse=None)\n",
    "\n",
    "    action_selection_node = nengo.Node(output=master.select_action, size_in=n_actor)\n",
    "    nengo.Connection(actor.neurons,\n",
    "                     action_selection_node, \n",
    "                     synapse=tau_gamma,\n",
    "                     transform=tau_gamma/(tau_gamma - v_gamma))\n",
    "    nengo.Connection(actor.neurons,\n",
    "                     action_selection_node,\n",
    "                     synapse=v_gamma,\n",
    "                     transform=(-v_gamma)/(tau_gamma - v_gamma))\n",
    "\n",
    "    step_node = nengo.Node(output=master.step, size_in=master.action_dim)\n",
    "    nengo.Connection(action_selection_node, step_node, synapse=None)\n",
    "\n",
    "    #####################################################\n",
    "    \n",
    "    critic = nengo.Ensemble(n_neurons=n_critic,\n",
    "                            dimensions=1,\n",
    "                            radius=critic_radius)\n",
    "    \n",
    "    critic_outer = nengo.Node(master.outer,\n",
    "                              size_in=n_place + n_critic,\n",
    "                              size_out=n_place * n_critic)\n",
    "    # convolve place spikes with epsilon\n",
    "    nengo.Connection(place.neurons,\n",
    "                     critic_outer[:n_place],\n",
    "                     synapse=tau_m,\n",
    "                     transform=((eps_0 * tau_m) / (tau_m - tau_s)))\n",
    "    nengo.Connection(place.neurons,\n",
    "                     critic_outer[:n_place],\n",
    "                     synapse=tau_s,\n",
    "                     transform=-((eps_0 * tau_s) / (tau_m - tau_s)))\n",
    "    # Pass raw critic spikes into critic_outer\n",
    "    nengo.Connection(critic.neurons, critic_outer[n_place:], synapse=None)\n",
    "                     \n",
    "    critic_learn = nengo.Node(master.critic,\n",
    "                              size_in=n_place * n_critic + n_place + 1,\n",
    "                              size_out=n_critic)\n",
    "    # convolve critic_outer output with k / tau_r\n",
    "    nengo.Connection(critic_outer, \n",
    "                     critic_learn[:n_place * n_critic], \n",
    "                     synapse=tau_k,\n",
    "                     transform=tau_k/((tau_k - v_k)*tau_r))\n",
    "    nengo.Connection(critic_outer, \n",
    "                     critic_learn[:n_place * n_critic], \n",
    "                     synapse=v_k,\n",
    "                     transform=(-v_k)/((tau_k - v_k)*tau_r))\n",
    "    # Pass convolved place spikes with epsilon into critic_learn\n",
    "    nengo.Connection(place.neurons,\n",
    "                     critic_learn[n_place * n_critic:-1],\n",
    "                     synapse=tau_m,\n",
    "                     transform=((eps_0 * tau_m) / (tau_m - tau_s)))\n",
    "    nengo.Connection(place.neurons,\n",
    "                     critic_learn[n_place * n_critic:-1],\n",
    "                     synapse=tau_s,\n",
    "                     transform=-((eps_0 * tau_s) / (tau_m - tau_s)))    \n",
    "                     \n",
    "    # connect critic_learn to critic neurons\n",
    "    nengo.Connection(critic_learn, critic.neurons, synapse=None)    \n",
    "    \n",
    "    td_error_node = nengo.Node(output=master.calc_td_error, size_in=n_critic)\n",
    "    # convolve critic spikes with (K' - K/tau_r)\n",
    "    nengo.Connection(critic.neurons,\n",
    "                     td_error_node,\n",
    "                     synapse=nengo.Lowpass(tau=tau_k),\n",
    "                     transform=((-tau_r - tau_k)/(tau_r*(tau_k-v_k))))\n",
    "    nengo.Connection(critic.neurons,\n",
    "                     td_error_node,\n",
    "                     synapse=nengo.Lowpass(tau=v_k),\n",
    "                     transform=((tau_r + v_k)/(tau_r*(tau_k-v_k))))\n",
    "    \n",
    "    nengo.Connection(td_error_node, actor_learn[-1], synapse=None)\n",
    "    nengo.Connection(td_error_node, critic_learn[-1], synapse=None)\n",
    "    \n",
    "    value_node = nengo.Node(output=master.calc_value, size_in=n_critic)\n",
    "    nengo.Connection(critic.neurons, \n",
    "                     value_node, \n",
    "                     synapse=tau_k,\n",
    "                     transform=tau_k/(tau_k - v_k))\n",
    "    nengo.Connection(critic.neurons, \n",
    "                     value_node, \n",
    "                     synapse=v_k,\n",
    "                     transform=(-v_k)/(tau_k - v_k))\n",
    "    \n",
    "    \n",
    "#     err_probe = nengo.Probe(td_error_node, synapse=None, sample_every=dt*stepSize)\n",
    "    action_probe = nengo.Probe(action_selection_node, synapse=None, sample_every=dt*stepSize)\n",
    "    value_probe = nengo.Probe(value_node, synapse=None, sample_every=dt*stepSize)\n",
    "#     place_probe = nengo.Probe(place, synapse=None, sample_every=dt*stepSize)\n",
    "#     state_probe = nengo.Probe(state_node, synapse=None, sample_every=dt*stepSize)\n",
    "    \n",
    "#     critic_spikes = nengo.Probe(critic.neurons)\n",
    "#     actor_spikes = nengo.Probe(actor.neurons)\n",
    "#     place_spikes = nengo.Probe(place.neurons)\n",
    "    \n",
    "sim = nengo.Simulator(model, dt=dt, optimize=True)\n",
    "sim.run(12000)\n",
    "\n",
    "# master.env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "                <div id=\"1367ccfc-77e3-4080-845d-048f1c60c263\" style=\"\n",
       "                    width: 100%;\n",
       "                    border: 1px solid #cfcfcf;\n",
       "                    border-radius: 4px;\n",
       "                    text-align: center;\n",
       "                    position: relative;\">\n",
       "                  <div class=\"pb-text\" style=\"\n",
       "                      position: absolute;\n",
       "                      width: 100%;\">\n",
       "                    0%\n",
       "                  </div>\n",
       "                  <div class=\"pb-fill\" style=\"\n",
       "                      background-color: #bdd2e6;\n",
       "                      width: 0%;\">\n",
       "                    <style type=\"text/css\" scoped=\"scoped\">\n",
       "                        @keyframes pb-fill-anim {\n",
       "                            0% { background-position: 0 0; }\n",
       "                            100% { background-position: 100px 0; }\n",
       "                        }\n",
       "                    </style>\n",
       "                    &nbsp;\n",
       "                  </div>\n",
       "                </div>"
      ],
      "text/plain": [
       "HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "              (function () {\n",
       "                  var root = document.getElementById('1367ccfc-77e3-4080-845d-048f1c60c263');\n",
       "                  var text = root.getElementsByClassName('pb-text')[0];\n",
       "                  var fill = root.getElementsByClassName('pb-fill')[0];\n",
       "\n",
       "                  text.innerHTML = 'Simulation finished in 0:14:59.';\n",
       "                  \n",
       "            if (100.0 > 0.) {\n",
       "                fill.style.transition = 'width 0.1s linear';\n",
       "            } else {\n",
       "                fill.style.transition = 'none';\n",
       "            }\n",
       "\n",
       "            fill.style.width = '100.0%';\n",
       "            fill.style.animation = 'none';\n",
       "            fill.style.backgroundImage = 'none'\n",
       "        \n",
       "                  \n",
       "                fill.style.animation = 'none';\n",
       "                fill.style.backgroundImage = 'none';\n",
       "            \n",
       "              })();\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# sim.run(300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.save('cache/place_actor_weights', master.place_actor_weights)\n",
    "# np.save('cache/place_critic_weights', master.place_critic_weights)\n",
    "# np.save('cache/reward_history', master.reward_history)\n",
    "# np.save('cache/values', sim.data[value_probe])\n",
    "# np.save('cache/actions', sim.data[action_probe])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PES_NEF.py                     place_actor_weights.npy\r\n",
      "README.md                      place_critic_weights.npy\r\n",
      "actions.npy                    \u001b[31mpvc-actor-critic.ipynb\u001b[m\u001b[m*\r\n",
      "nef-actor-critic-pes.ipynb     q-learning.ipynb\r\n",
      "nef-actor-critic-td-ltp.ipynb  reward_history.npy\r\n",
      "nengo-tests.ipynb              test.py\r\n",
      "paper.py                       values.npy\r\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization and debugging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "240000"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sim.data[value_probe])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rasterplot(sim.trange()[:10], sim.data[place_spikes][:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rasterplot(sim.trange()[:], sim.data[actor_spikes][:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# rasterplot(sim.trange()[:10], sim.data[critic_spikes][:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# plt.plot(sim.data[err_probe], label='td_error')\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# plt.plot(sim.data[value_probe], label='value')\n",
    "# plt.title('Value')\n",
    "# plt.ylabel('V(x(t))')\n",
    "# plt.xlabel('t')\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'a(x(t))')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize=(12,4))\n",
    "\n",
    "ax[0].plot(sim.data[value_probe], label='value')\n",
    "ax[0].set_title('Value')\n",
    "ax[0].set_ylabel('V(x(t))')\n",
    "ax[0].set_xlabel('t')\n",
    "\n",
    "ax[1].plot(sim.data[action_probe])\n",
    "ax[1].set_title(f'Action')\n",
    "ax[1].set_xlabel('t')\n",
    "ax[1].set_ylabel('a(x(t))')\n",
    "\n",
    "# plt.plot(sim.data[action_probe], label='action')\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# end = 1000\n",
    "# plt.plot(sim.data[place_probe][:end], label='place')\n",
    "# plt.plot(sim.data[state_probe][:end], label='state')\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# plt.plot(master.reward_history)\n",
    "# plt.xlabel('Trial')\n",
    "# plt.title('Total reward per trial')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Trial')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize=(12,4))\n",
    "\n",
    "ax[0].plot(master.reward_history)\n",
    "ax[0].set_xlabel('Trial')\n",
    "ax[0].set_title('Total reward per trial')\n",
    "\n",
    "h = 100\n",
    "ax[1].plot(np.convolve(master.reward_history, np.ones(h)/h, 'valid'))\n",
    "ax[1].set_title(f'{h}-trial moving average of rewards')\n",
    "ax[1].set_xlabel('Trial')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}