NeuronalDynamics.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:e039d7bbdf6872f7113b3428aba8e4a2c08aafc78d225dcdb433cc305ce32727"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sugandha Sharma\n",
      "(ID: 20401693)"
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "1. Building an ensemble of neurons"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline \n",
      "\n",
      "import numpy\n",
      "import nengo\n",
      "from nengo.utils.ensemble import tuning_curves\n",
      "from nengo.dists import Uniform\n",
      "\n",
      "def lif_neurons(tau_rc = 0.02, tau_ref = 0.002, radius = 1.0, flag = 0):\n",
      "\n",
      "    N = 100\n",
      "    lif_model = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref)\n",
      "\n",
      "    model = nengo.Network(label='Neurons')\n",
      "    with model:\n",
      "        neurons = nengo.Ensemble(N, dimensions=1, radius = radius, intercepts = Uniform(-1.0, 1.0), \n",
      "                                 max_rates = Uniform(100,200), neuron_type = lif_model) \n",
      "    \n",
      "    sim = nengo.Simulator(model)\n",
      "    x, A = tuning_curves(neurons, sim)\n",
      "\n",
      "    if flag:\n",
      "        figure()\n",
      "        plot(x, A)\n",
      "        xlabel('x')\n",
      "        ylabel('firing rate (Hz)')\n",
      "\n",
      "    with model:\n",
      "        connection = nengo.Connection(neurons, neurons) #This is just to generate the decoders\n",
      "\n",
      "    sim = nengo.Simulator(model)\n",
      "    d = sim.data[connection].decoders.T\n",
      "    x, A = tuning_curves(neurons, sim)\n",
      "    xhat = numpy.dot(A, d)\n",
      "    \n",
      "    rmse = np.sqrt(np.average((x-xhat)**2))\n",
      "\n",
      "\n",
      "    if flag:\n",
      "        print 'RMSE with %d neurons is %g'%(N, rmse)\n",
      "        figure()\n",
      "        plot(x, x, 'b' , label = 'x')\n",
      "        plot(x, xhat, 'g' , label = 'xhat')\n",
      "        xlabel('$x$')\n",
      "        ylabel('$\\hat{x}$')\n",
      "        legend()\n",
      "        figure()\n",
      "        plot(x, x-xhat, 'g')\n",
      "        xlabel('$x$')\n",
      "        ylabel('$x$ - $\\hat{x}$')\n",
      "\n",
      "\n",
      "    return rmse\n",
      "    \n",
      "def main():\n",
      "    \n",
      "    # Par a) - Tuning curves and representational accuracy plot\n",
      "    lif_neurons(tau_rc = 0.02, tau_ref = 0.002, radius = 1.0, flag = 1)\n",
      "    \n",
      "    # ---------------------------------------------------------------------------------------------------------------------------\n",
      "    # Part b) - Effect of changing the radius of neurons on RMSE\n",
      "    \n",
      "    rmse_array = np.zeros(4)\n",
      "    radius = 1\n",
      "    i = 0\n",
      "    for value in range(4):\n",
      "        rmse_array[i] = lif_neurons(tau_rc = 0.02, tau_ref = 0.002, radius = radius, flag = 0)\n",
      "        radius = radius + 1\n",
      "        i = i + 1\n",
      "        \n",
      "    figure()\n",
      "    plot([1,2,3,4], rmse_array)\n",
      "    xlabel(\"neuron radius\")\n",
      "    ylabel(\"RMSE\")\n",
      "    title (\"RMSE with an increase in radius\")\n",
      "    #print rmse_array\n",
      "        \n",
      "    # ---------------------------------------------------------------------------------------------------------------------------\n",
      "    # Part c) - Effect of change in tau_ref on RMSE\n",
      "    \n",
      "    rmse_array = np.zeros(7)\n",
      "    tau_ref_array = np.zeros(7)\n",
      "    tau_ref = 0.002\n",
      "    i = 0\n",
      "    for value in range(7):\n",
      "        rmse_array[i] = lif_neurons(tau_rc = 0.02, tau_ref = tau_ref, radius = 1, flag = 0)\n",
      "        tau_ref_array[i] = tau_ref\n",
      "        #print tau_ref\n",
      "        tau_ref = tau_ref + 0.0005\n",
      "        i = i + 1\n",
      "        \n",
      "    figure()\n",
      "    plot(tau_ref_array, rmse_array)\n",
      "    xlabel(\"tau_ref\")\n",
      "    ylabel(\"RMSE\")\n",
      "    title (\"RMSE with an increase in tau_ref\")\n",
      "     \n",
      "    # ---------------------------------------------------------------------------------------------------------------------------\n",
      "    # Part c) - Effect of change in tau_RC on RMSE\n",
      "    \n",
      "    rmse_array = np.zeros(7)\n",
      "    tau_rc_array = np.zeros(7)\n",
      "    tau_rc = 0.02\n",
      "    i = 0\n",
      "    for value in range(7):\n",
      "        rmse_array[i] = lif_neurons(tau_rc = tau_rc, tau_ref = 0.002, radius = 1, flag = 0)\n",
      "        tau_rc_array[i] = tau_rc\n",
      "        #print tau_rc\n",
      "        tau_rc = tau_rc + 0.02\n",
      "        i = i + 1\n",
      "        \n",
      "    figure()\n",
      "    plot(tau_rc_array, rmse_array)\n",
      "    xlabel(\"tau_rc\")\n",
      "    ylabel(\"RMSE\")\n",
      "    title (\"RMSE with an increase in tau_rc\")\n",
      "        \n",
      "if __name__ == \"__main__\": main()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "2. Connecting neurons"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.dists import Uniform\n",
      "from nengo.utils.functions import piecewise\n",
      "import nengo\n",
      "\n",
      "def connnecting_neurons(stim_signal, flag=0):\n",
      "    \n",
      "    model = nengo.Network()\n",
      "\n",
      "    with model:\n",
      "        \n",
      "        # create an input\n",
      "        stim = nengo.Node(piecewise({0:stim_signal, 0.1:0 }))\n",
      "\n",
      "        # Create two neuronal ensembles\n",
      "        ens_A = nengo.Ensemble(100, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                               max_rates = Uniform(100,200), neuron_type = nengo.LIF(tau_rc = 0.02,tau_ref = 0.002))\n",
      "        ens_B = nengo.Ensemble(50, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                               max_rates = Uniform(100,200), neuron_type = nengo.LIF(tau_rc = 0.02,tau_ref = 0.002))\n",
      "\n",
      "        nengo.Connection(stim, ens_A, synapse = 0.01)       # Connect the input to the first neuronal ensemble\n",
      "        \n",
      "         # Connect the first neuronal ensemble to the second \n",
      "        if flag == 1:\n",
      "            nengo.Connection(ens_A, ens_B, synapse = 0.01, function = lambda x: 1.0 - 2.0*x)    \n",
      "        else:\n",
      "            nengo.Connection(ens_A, ens_B, synapse = 0.01)     \n",
      "\n",
      "    # get data from the simulation\n",
      "    with model:\n",
      "        stim_probe = nengo.Probe(stim)\n",
      "        A_probe = nengo.Probe(ens_A, synapse=0.01)  \n",
      "        B_probe = nengo.Probe(ens_B, synapse=0.01)\n",
      "\n",
      "\n",
      "    sim = nengo.Simulator(model)\n",
      "    sim.run(0.5)\n",
      "\n",
      "    figure()\n",
      "    plt.title(\"Input Signal\")\n",
      "    plt.plot(sim.trange(), sim.data[stim_probe])\n",
      "    ylim(-0.2, 1.2)\n",
      "\n",
      "    figure()\n",
      "    plt.title(\"Ensemble A\")\n",
      "    plt.plot(sim.trange(), sim.data[A_probe])\n",
      "    #ylim(-0.2, 1.2)\n",
      "\n",
      "    figure()\n",
      "    plt.title(\"Ensemble B\")\n",
      "    plt.plot(sim.trange(), sim.data[B_probe])\n",
      "    #ylim(-0.2, 1.2)\n",
      "    \n",
      "\n",
      "def main():\n",
      "    \n",
      "    # Part a)\n",
      "    stim_signal = 1.0\n",
      "    connnecting_neurons(stim_signal, flag = 0)\n",
      "    \n",
      "    #Part b)\n",
      "    stim_signal = 1.0\n",
      "    connnecting_neurons(stim_signal, flag = 1)\n",
      "    \n",
      "\n",
      "if __name__ == \"__main__\": main()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "3. Dynamics"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "a)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "    \n",
      "    stim = nengo.Node(piecewise({0.04:0.9, 1:0 }))\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(1.5)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble output\")\n",
      "plt.legend(loc=\"best\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "b) Change the model to use rate neurons"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "    \n",
      "    stim = nengo.Node(piecewise({0.04:0.9, 1:0 }))\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIFRate())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # change the model to a rate model\n",
      "    model.config[nengo.Ensemble].neuron_type = nengo.LIFRate()\n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(1.5)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble output\")\n",
      "plt.legend(loc=\"best\")\n",
      "plt.ylim(-0.2,1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "c)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "        \n",
      "    stim = nengo.Node(piecewise({0.04:0.9, 0.16:0 }))\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(1.5)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble output\")\n",
      "plt.legend(loc=\"best\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "d) Ramp Input"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "        \n",
      "    stim = nengo.Node(lambda t: 2*t if t<0.45 else 0)\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(1.5)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble output\")\n",
      "plt.legend(loc=\"best\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "e) Sinusoidal Input"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "        \n",
      "    stim = nengo.Node(lambda t: 5*sin(5*t))\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(1.5)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble output\")\n",
      "plt.plot(sim.trange(), -cos(5*sim.trange()), 'g', label=\"- cos(5t)\")\n",
      "plt.legend(loc=\"best\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "f)  Non Linear Dynamical Systems"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Rossler Attractor"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A Rossler Attractor can be expressed by following differential equations:\n",
      "\n",
      "$$\n",
      "x'(t) = -(y(t) + z(t)) \\\\\\\n",
      "y'(t) = x(t) + a y(t) \\\\\\\n",
      "z'(t) = b + x(t)z(t) - c z(t)\n",
      "$$\n",
      "\n",
      "These equations can be written as follows where: \n",
      "$$\\ x => x_0,  y => x_1,  z => x_2 $$\n",
      "\n",
      "$$\n",
      "\\dot{x}_0 = -(x_1 + x_2) \\\\\\\n",
      "\\dot{x}_1 = x_0 + a * x_1  \\\\\\\n",
      "\\dot{x}_2 = b + x_0 x_2 - c * x_2  = b - x_2 (c - x_0)\n",
      "$$"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import nengo\n",
      "from mpl_toolkits.mplot3d import Axes3D\n",
      "import numpy as np\n",
      "import matplotlib\n",
      "import matplotlib.pyplot as plt\n",
      "\n",
      "model = nengo.Network('Rossler Attractor', seed=3)\n",
      "\n",
      "tau = 0.1\n",
      "a = 0.5\n",
      "b = 1\n",
      "c = 13\n",
      "\n",
      "\n",
      "\"\"\"a = 0.5\n",
      "b = 0.5\n",
      "c = 5.7\"\"\"\n",
      "\n",
      "def feedback(x):\n",
      "    \n",
      "    # original\n",
      "    dx0 = -x[1] - x[2]\n",
      "    dx1 = x[0] + a*x[1]\n",
      "    dx2 = b + x[2]*x[0] - c*x[2]\n",
      "    return [dx0 * tau + x[0], \n",
      "            dx1 * tau + x[1], \n",
      "            dx2 * tau + x[2]]\n",
      "\n",
      "with model:\n",
      "    rossler = nengo.Ensemble(2000, dimensions=3, radius=60)\n",
      "    \n",
      "    nengo.Connection(rossler, rossler, function=feedback, synapse=tau)\n",
      "    \n",
      "    rossler_p = nengo.Probe(rossler, synapse=tau)\n",
      "    \n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(20)\n",
      "\n",
      "figure(figsize=(12,4))\n",
      "subplot(1,2,1)\n",
      "plot(sim.trange(), sim.data[rossler_p]);\n",
      "xlabel('Time (s)')\n",
      "ylabel('State value')\n",
      "       \n",
      "subplot(1,2,2)\n",
      "plot(sim.data[rossler_p][:,0], sim.data[rossler_p][:,1])\n",
      "xlabel('$x_0$')\n",
      "ylabel('$x_1$')\n",
      "\n",
      "\"\"\"figure()\n",
      "plot(sim.trange(), sim.data[rossler_p][:,0]);\n",
      "figure()\n",
      "plot(sim.trange(), sim.data[rossler_p][:,1]);\n",
      "figure()\n",
      "plot(sim.trange(), sim.data[rossler_p][:,2]);\"\"\"\n",
      "\n",
      "\"\"\"fig = plt.figure()\n",
      "ax = Axes3D(fig)\n",
      "ax.plot(sim.data[rossler_p][:,2], \n",
      "        sim.data[rossler_p][:,0], \n",
      "        sim.data[rossler_p][:,1])\"\"\"\n",
      "\n",
      "ax = plt.figure().add_subplot(111, projection='3d')\n",
      "ax.plot(sim.data[rossler_p][:, 0],\n",
      "        sim.data[rossler_p][:, 1],\n",
      "        sim.data[rossler_p][:, 2])\n",
      "\n",
      "ax.set_xlabel('$x_0$')\n",
      "ax.set_ylabel('$x_1$')\n",
      "ax.set_zlabel('$x_2$')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Double Integrator"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import matplotlib.pyplot as plt\n",
      "from nengo.utils.functions import piecewise\n",
      "from nengo.dists import Uniform\n",
      "import nengo\n",
      "\n",
      "model = nengo.Network(label='Integrator')\n",
      "with model:\n",
      "    \n",
      "    stim = nengo.Node(piecewise({0: 0, 0.2: -1, 1: 0, 2: 2, 3: 0, 4: -2, 5: 0, 6: 1, 7: 0}))\n",
      "    #stim = nengo.Node(piecewise({0: 0, 1: 1, 2: -2, 3: 2, 4: -2, 5: 2, 6: -2, 7: 1, 8: 0}))\n",
      "    \n",
      "    # An ensemble consisting of 200 neurons\n",
      "    ens_A = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    tau = 0.05\n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(stim, ens_A, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_A, ens_A, transform=1, synapse=tau) \n",
      "    \n",
      "    # create another ensemble for creating a double integrator\n",
      "    ens_B = nengo.Ensemble(200, dimensions=1, radius = 1, intercepts = Uniform(-1.0, 1.0), \n",
      "                           max_rates = Uniform(100,200), neuron_type = nengo.LIF())\n",
      "    \n",
      "    # Connection of the input to the ensemble\n",
      "    nengo.Connection(ens_A, ens_B, transform=tau, synapse=0.005) \n",
      "\n",
      "    # Connect the ensemble back to itself\n",
      "    nengo.Connection(ens_B, ens_B, transform=1, synapse=tau) \n",
      "    \n",
      "    # Add probes\n",
      "    input_probe = nengo.Probe(stim)\n",
      "    A_probe = nengo.Probe(ens_A, synapse=0.01)\n",
      "    B_probe = nengo.Probe(ens_B, synapse=0.01)\n",
      "    \n",
      "    \n",
      "# Create the simulator and run the simulation for 1.5 seconds\n",
      "sim = nengo.Simulator(model)\n",
      "sim.run(9)    \n",
      "\n",
      "plt.plot(sim.trange(), sim.data[input_probe], 'b', label=\"Input\")\n",
      "plt.plot(sim.trange(), sim.data[A_probe], 'r', label=\"Ensemble A output\")\n",
      "plt.plot(sim.trange(), sim.data[B_probe], 'k', label=\"Ensemble B output\")\n",
      "plt.legend(loc=\"best\")\n",
      "legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.0)\n",
      "ylim(-2.5, 2.5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}