How to implement the step math function when the membrane potential depends on the past spikes?

patelvrajn · March 17, 2019, 3:37am

I am trying to implement a learning model whose membrane potential function is dependent on past spiking behavior how would I implement such a function in the step math function?

arvoelke · March 17, 2019, 3:57pm

I can see that you’ve asked for help in the thread How do you create a neural model in Nengo? and received a link to the tutorial: https://www.nengo.ai/nengo/examples/usage/rectified_linear.html

At this point you might want to dig into the Nengo code for more reference. For example, here is how the Izhikevich model is implemented. Note the recovery parameter used to track additional state information between successive calls to step_math. In your case, such a parameter could be used to remember values such as ‘the time that each neuron last spiked’.

github.com

nengo/nengo/blob/36070176f05da29ee896f27917a470d83e7d87c5/nengo/neurons.py#L630-L651


def step_math(self, dt, J, spiked, voltage, recovery):
    """Implement the Izhikevich nonlinearity."""
    # Numerical instability occurs for very low inputs.
    # We'll clip them be greater than some value that was chosen by
    # looking at the simulations for many parameter sets.
    # A more principled minimum value would be better.
    J = np.maximum(-30., J)


    dV = (0.04 * voltage ** 2 + 5 * voltage + 140 - recovery + J) * 1000
    voltage[:] += dV * dt


    # We check for spikes and reset the voltage here rather than after,
    # which differs from the original implementation by Izhikevich.
    # However, calculating recovery for voltage values greater than
    # threshold can cause the system to blow up, which we want
    # to avoid at all costs.
    spiked[:] = (voltage >= 30) / dt
    voltage[spiked > 0] = self.reset_voltage


    dU = (self.tau_recovery * (self.coupling * voltage - recovery)) * 1000

This file has been truncated. show original

It may also help if you could give more detail about your model. Depending what information is needed by step_math, there could be several different ways of going about this (e.g., as a custom unsupervised learning rule, or by doing something similar to the below).

github.com

nengo/nengo/blob/36070176f05da29ee896f27917a470d83e7d87c5/nengo/neurons.py#L560-L564


def step_math(self, dt, J, output, voltage, ref, adaptation):
    """Implement the AdaptiveLIF nonlinearity."""
    n = adaptation
    LIF.step_math(self, dt, J - n, output, voltage, ref)
    n += (dt / self.tau_n) * (self.inc_n * output - n)

patelvrajn · March 21, 2019, 10:27pm

I now understand how this is done, would it be possible to ask a follow-up question;

I understand that in Python that your allowed to override functions using a different number of parameters like in this situation where step_math is being overrided with a different signature. However, it was my understanding that this was bad practice in the sense it violates the Liskov substitution principle and introduces weird behaviors. Am I incorrect in my understanding? Also if this is incorrect, can I add any number of parameters to any of these functions?

arvoelke · March 22, 2019, 2:25pm

I don’t think LSP is really violated in this situation as you can think of the list of additional parameters as a single *states argument. That is, the abstraction is actually:

step_math(dt, J, output, *states)

The implementation of the SimNeurons operator, which is responsible for calling the step_math function, is shown below:

github.com

nengo/nengo/blob/36070176f05da29ee896f27917a470d83e7d87c5/nengo/builder/neurons.py#L72-L78


J = signals[self.J]
output = signals[self.output]
states = [signals[state] for state in self.states]


def step_simneurons():
    self.neurons.step_math(dt, J, output, *states)
return step_simneurons

where states is a list of Signal objects. But I just realized that I forgot to mention something important in my last post (although it is mentioned in the tutorial). You can add as many states as you would like, but the builder function still needs to be overridden to create each corresponding signal. This is how the simulator knows how to call your step_math function with the correct additional arguments. An example is given in the tutorial mentioned before, and shown below for the case of the Izhikevich model:

github.com

nengo/nengo/blob/36070176f05da29ee896f27917a470d83e7d87c5/nengo/builder/neurons.py#L264-L275


model.sig[neurons]['voltage'] = Signal(
    np.ones(neurons.size_in) * izhikevich.reset_voltage,
    name="%s.voltage" % neurons)
model.sig[neurons]['recovery'] = Signal(
    np.ones(neurons.size_in)
    * izhikevich.reset_voltage
    * izhikevich.coupling, name="%s.recovery" % neurons)
model.add_op(SimNeurons(neurons=izhikevich,
                        J=model.sig[neurons]['in'],
                        output=model.sig[neurons]['out'],
                        states=[model.sig[neurons]['voltage'],
                                model.sig[neurons]['recovery']]))

If you need something that isn’t supported by this abstraction you can even write your own operator (instead of using SimNeurons) but I don’t think that will be necessary for your case.

bartekkrol96 · December 17, 2023, 1:53pm

Hi @arvoelke, great explanation of the problem. I’m currently working on a similar case and I probably need support. Let’s say I want to create a simple Node + Ensemble model that will allow me to control the gain value with a slider (from the Nengo GUI). Following your instructions step by step, I have the following elements:

new neuron model

class MyNeuron(LIF):
    def step_math(self, dt, J, spiked, voltage, refractory_time, gain):
        super().step_math(dt, J*gain, spiked, voltage, refractory_time)

then i create builder function to register my model with new “gain” parameter

@Builder.register(MyNeuron)
def build_gain_model(model: Model, my_neuron, neurons):
    model.sig[neurons]['gain'] = Signal(
        np.ones(neurons.size_in), name="%s.gain" % neurons)
    model.sig[neurons]['voltage'] = Signal(
        np.zeros(neurons.size_in), name="%s.voltage" % neurons)
    model.sig[neurons]['refractory_time'] = Signal(
        np.zeros(neurons.size_in), name="%s.refractory_time" % neurons)
    model.add_op(SimNeurons(neurons=my_neuron,
                            J=model.sig[neurons]['in'],
                            output=model.sig[neurons]['out'],
                            states=[model.sig[neurons]['voltage'],
                                    model.sig[neurons]['refractory_time'],
                                    model.sig[neurons]['gain']]))

and now the model itself

model = nengo.Network()
with model:
    gain_node = nengo.Node([2], label="gain_node")
    a = nengo.Ensemble(n_neurons=1, dimensions=1, neuron_type=MyNeuron(), label="main_ensemble")

    nengo.Connection(gain_node, a)

everything seems to be working, but the gain value remains unchanged throughout the simulation. How can I set it dynamically, for example with a slider from the GUI level?
I don’t understand at all where the changes in values of voltage and recovery come from and how to control the gain value “online”