The basis of many of our cognitive models is the integrator. Mathematically, the output of this network should be the integral of the inputs to this network.
- Practically speaking, this means that if the input to the network is zero, then its output will stay at whatever value it is currently at. This makes it the basis of a neural memory system, as a representation can be stored over time.
- Integrators are also often used in sensorimotor systems, such as eye control
For an integrator, a neural ensemble needs to connect to itself with a transformation weight of 1, and have an input with a weight of , which is the same as the synaptic time constant of the neurotransmitter used.
Create a one-dimensional ensemble called Integrator. Use 100 neurons and a radius of 1.
Add two terminations with synaptic time constants of 0.1s. Call the first one input`` and give it a weight of 0.1. Call the second one ``feedback and give it a weight of 1.
Create a new Function input using a Constant Function with a value of 1.
Connect the Function input to the input termination
Connect the X origin of the ensemble back to its own feedback termination.
Go to Interactive Plots. Create a graph for the value of the ensemble (right-click on the ensemble and select “value”).
Press Play to run the simulation. The value stored in the ensemble should linearly increase, reaching a value of 1 after approximately 1 second.
- You can increase the amount of time shown on the graphs in Interactive Plots. Do this by clicking on the small downwards-pointing arrow at the bottom of the window. This will reveal a variety of settings for Interactive Plots. Change the “time shown” to 1.
We can also run the model with a more complex input. Change the Function input using the following command from the script console (after clicking on it in the black model editing mode interface). Press Ctrl-1 (Command-1 OS X) to show the script console:
You can see what this function looks like by right-clicking on it in the editing interface and selecting “plot function” (Note: Function index = 0, Start = 0, Increment = 0.001, End = 1).
By using a shorter time constant, the network dynamics are more sensitive to small-scale variation (i.e. noise).
This indicates how important the use of a particular neurotransmitter is, and why there are so many different types with vastly differing time constants.
- AMPA: 2-10ms
- GABA:subscript:A: 10-20ms
- NMDA: 20-150ms
- The actual details of these time constants vary across the brain as well. We are collecting empirical data on these from various sources at http://ctnsrv.uwaterloo.ca/cnrglab/node/246
You can also run this example using “integrator.py” in the demo directory
We can also build an integrator where the feedback transformation (1 in the previous model) can be controlled.
- This allows us to build a tunable filter.
This requires the use of multiplication, since we need to multiply two stored values together. This was covered in the previous part of the tutorial.
We can efficiently implement this by using a two-dimensional ensemble. One dimension will hold the value being represented, and the other dimension will hold the transformation weight.
Create a two-dimensional neural ensemble with 225 neurons and a radius of 1.5.
Create the following three terminations:
- input: time constant of 0.1, 1 dimensional, with a transformation matrix of [0.1 0]. This acts the same as the input in the previous model, but only affects the first dimension.
- control: time constant of 0.1, 1 dimensional, with a transformation matrix of [0 1]. This stores the input control signal into the second dimension of the ensemble.
- feedback: time constant of 0.1, 1 dimensional, with a transformation matrix of [1 0]. This will be used in the same manner as the feedback termination in the previous model.
Create a new origin that multiplies the values in the vector together
- This is exactly the same as the multiplier in the previous part of this tutorial
- This is a 1 dimensional output, with a User-defined Function of x0*x1
Create two function inputs called input and control. Start with Constant functions with a value of 1
Use the script console to set the input function by clicking on it and entering the same input function as used above:that.functions=[ca.nengo.math.impl.PiecewiseConstantFunction([0.2,0.3,0.44,0.54,0.8,0.9],[0,5,0,-10,0,5,0])]
Connect the input function to the input termination, the control function to the control termination, and the product origin to the feedback termination.