Can anyone explain the behaviour of this LIF neuron?

[rafaelblevin821]

So, I have been looking at the behavior of the LIf neuron on Jupiter Notebook:

Consider the settings as:

I would like to know why some of the spikes drop almost vertically instead of decaying as per the decay rate of 100ms. If you look at the behavior, some spikes seem to decay at the expected rate, while others take a steep vertical drop.

Why does it behave like this?

[Hananel-Hazan]

Interesting. Can you past the code here?

[rafaelblevin821]

Sure, I'm running it as a notebook:

import os
import torch
import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display
from ipywidgets import interactive

from bindsnet.encoding import *
from bindsnet.network import Network
from bindsnet.network.nodes import Input, LIFNodes, IFNodes, SRM0Nodes, AdaptiveLIFNodes
from bindsnet.network.topology import Connection
from bindsnet.network.monitors import Monitor
from bindsnet.network.monitors import NetworkMonitor

from bindsnet.analysis.plotting import plot_spikes, plot_voltages, plot_input, plot_weights

# initialize network
network = Network()

# Create sliders with initial values
rest = widgets.FloatSlider(value=-65.0, min=-100.0, max=0.0, step=0.1, description='Rest:', continuous_update=False)
reset = widgets.FloatSlider(value=-60.0, min=-100.0, max=0.0, step=0.1, description='Reset:', continuous_update=False)
thresh = widgets.FloatSlider(value=-52.0, min=-100.0, max=0.0, step=0.1, description='Thresh:', continuous_update=False)
refrac = widgets.IntSlider(value=5, min=0, max=100, step=1, description='Refrac:', continuous_update=False)
tc_decay = widgets.FloatSlider(value=100.0, min=0.0, max=1000.0, step=0.1, description='Tc decay:', continuous_update=False)
tc_trace = widgets.FloatSlider(value=20.0, min=0.0, max=1000.0, step=0.1, description='Tc trace:', continuous_update=False)


def run_simulation(rest, reset, thresh, refrac, tc_decay, tc_trace):
    # set number of neurons
    num_inputs = 1
    num_neurons = 1

    # simulation time
    time = 500
    dt = 1

    # configure weights for the synapses between the input layer and LIF layer
    w = torch.round(torch.abs(2 * torch.randn(num_inputs, num_neurons)))

    # create input spike data, where each spike is distributed according to Bernoulli(0.1)
    input_data = torch.bernoulli(0.3 * torch.ones(time, num_inputs)).byte()
    inputs = {"Input Layer": input_data}

    # initialize list of neuron models
    neuron_models = [IFNodes(n=num_neurons, rest=rest, reset=reset, thresh=thresh, refrac=refrac, tc_decay=tc_decay, tc_trace=tc_trace),
                     LIFNodes(n=num_neurons, rest=rest, reset=reset, thresh=thresh, refrac=refrac, tc_decay=tc_decay, tc_trace=tc_trace),
                     AdaptiveLIFNodes(n=num_neurons, rest=rest, reset=reset, thresh=thresh, refrac=refrac, tc_decay=tc_decay, tc_trace=tc_trace),
                     SRM0Nodes(n=num_neurons, rest=rest, reset=reset, thresh=thresh, refrac=refrac, tc_decay=tc_decay, tc_trace=tc_trace)]
    neuron_types = ["IF Neuron","LIF Neuron","Adaptive LIF Neuron","SRM0 Neuron"]
    spikes={}
    voltages={}

    s_ims = None
    s_axes = None
    v_ims = None
    v_axes = []

    for neuron_model_index in range(len(neuron_models)):
        # Re-initialize the network for each neuron model
        network = Network()

        # initialize input and neuron layers
        input_layer = Input(n=num_inputs)
        neuron_layer = neuron_models[neuron_model_index]

        # connection between the input layer and the LIF layer
        connection = Connection(
            source=input_layer, target=neuron_layer,w=w)

        # create a monitor
        neuron_layer_monitor = Monitor(
            obj=neuron_layer,
            state_vars=("s", "v"),  # Record spikes and voltages.
            time=time,)  # Length of simulation (if known ahead of time).

        # add layers to network
        network.add_layer(
            layer=input_layer, name="Input Layer")
        
        network.add_layer(
            layer=neuron_layer, name="Neuron Layer")
        
        # add connection to network
        network.add_connection(
            connection=connection, source="Input Layer", target="Neuron Layer")

        # add monitor to the network
        network.add_monitor(monitor=neuron_layer_monitor, name="Neuron Layer")

        # simulate network on input data
        network.run(inputs=inputs, time=time)

        # retrieve and plot simulation spike, voltage data from monitors
        v_axes = plot_voltages({neuron_types[neuron_model_index] : neuron_layer_monitor.get("v")}, plot_type="line",axes=v_axes)

    plt.show()
    
# Link sliders to the simulation function
interactive_plot = interactive(run_simulation, rest=rest, reset=reset, thresh=thresh, refrac=refrac, tc_decay=tc_decay, tc_trace=tc_trace)

# Display sliders
display(interactive_plot)

[Hananel-Hazan]

What Notebook do you use? I am trying to run your code on VScode notebook, when press run, the last peace of code runs without stopping.

[Hananel-Hazan]

Ok, I successfully run the script on regular jupyter notebook (not the VScode Notebook).

[rafaelblevin821]

To be clear, I have circled the expected behavior as green, but I'm unsure about the instantaneous post-spike voltage drops, especially sub-threshold.

[Hananel-Hazan]

Can you share the parameters you use in this graph, that I can replicate this on my side?

When I running the code I dont get the same graphs

[rafaelblevin821]

You will get slightly different plots each time due to the Bernoulli distributed input. You also don't seem to have set the reset value. I apologize, but I cannot see the parameter setting from your posted image.

You can also change the simulation time, like I did in the previous post, to 100 instead of 500.
The problem is that I want to understand why some spikes drop almost instantaneously to rest, even ones that have not reached the threshold; I thought tc_decay would control the decay rate in the spikes...

[Hananel-Hazan]

This is what I get with the following parameters

Also, its will be hard to reproduce or to think of the cause to the phenomena you mention if you using random inputs and weights. Please change the code to a fixed weight and constant input (in some freq) and try to replicate your finding and post the code back here.

[rafaelblevin821]

Hi @Hananel-Hazan what did your output for the LIF neuron look like?

[Hananel-Hazan]

Similar to this one, no unexpected drops of spikes

[SimonInParis]

It looks like negative weights inducing inter neuron inhibition, hence the quick drops on membrane voltage. I might be wrong. Le mer. 9 août 2023 à 17:34, Hananel Hazan ***@***.***> a écrit :

…

This is what I get with the following parameters [image: Screenshot 2023-08-09 113043] <https://user-images.githubusercontent.com/3954715/259462361-145dab6e-676e-45cb-a005-da0b723f740a.png> Also, its will be hard to reproduce or to think of the cause to the phenomena you mention if you using random inputs and weights. Please change the code to a fixed weight and constant input (in some freq) and try to replicate your finding and post the code back here. — Reply to this email directly, view it on GitHub <#649 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AKZ2IOCVZPGN7AEDBRQ7FG3XUOUW7ANCNFSM6AAAAAA3JCEA7M> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[rafaelblevin821]

@SimonInParis there should be no negative weights as the weights tensor is 'absolute' numbers and the inputs are binary.

[rafaelblevin821]

This is what I get with the following parameters

Also, its will be hard to reproduce or to think of the cause to the phenomena you mention if you using random inputs and weights. Please change the code to a fixed weight and constant input (in some freq) and try to replicate your finding and post the code back here.

@Hananel-Hazan okay, so I changed the weights and input tensors to w = torch.tensor([[0.5]]) and input_data = torch.ones(time, num_inputs, dtype=torch.uint8) respectively. I have set the weight tensor w to a known positive value (0.5) and the input tensor input_data to have all elements equal to 1, representing the presence of spikes in all time steps for the single input neuron. I am now getting the expected behavior.

But it still leaves the question, why are some spikes not reaching the threshold and resetting immediately instead of decaying at the set rate of decay?

Here, I have highlighted all the spikes that did not reach the threshold, but reset immediately with no decay time:

Is there an explanation for this?

[Hananel-Hazan]

What parameters did you use to get this behavioral? Did this last graph use the code with the modification you made here?

[Hananel-Hazan]

In addition, please overlay the value of the variable s on the voltage graph. It is possible that the LIF algorithm considers this as a spike, even though it is not shown in the voltage graph. This can happen if the voltage V just crosses the threshold in the same iteration that the LIF algorithm adds the voltage. The algorithm first adds the voltage and then checks if V crosses the threshold. In this case, V will be reset and the spike will be omitted, but this will not be reflected in the voltage graph. This is an edge case, but it is done this way to save running time.

[rafaelblevin821]

Hi @Hananel-Hazan , no, I used the original code. Regardless of the inputs and weights, I would not expect the non-threshold spikes to reset immediately without decay and refractory period. As far as I know, no matter what the inputs or weights are, the neuron should not behave like this.
When running on noisy images, the inputs will be similar to the random tensors and not uniform values, so I need to understand this behavior.

[Hananel-Hazan]

Not sure I understand what you mean.

Regardless of the inputs and weights, I would not expect the non-threshold spikes to reset immediately without decay and refractory period.

In case the input provided to the neuron cause the neuron to pass the threshold, why do you expect it to wait to the next cycle to spike? at that point, no decaying needed, the neuron already pass the threshold. Moreover, from your graphs, the refractory period did happened.

I suspect that if you plot the s value (spikes) you will see that the neuron did spike during the "missing" voltage period in the plot you show here.
Please make another run and plot the v and the s and let see if the neuron miss the spike and reset the voltage unexpectedly.

[rafaelblevin821]

What parameters did you use to get this behavioral? Did this last graph use the code with the modification you made here?

Not sure I understand what you mean.

Regardless of the inputs and weights, I would not expect the non-threshold spikes to reset immediately without decay and refractory period.

In case the input provided to the neuron cause the neuron to pass the threshold, why do you expect it to wait to the next cycle to spike? at that point, no decaying needed, the neuron already pass the threshold. Moreover, from your graphs, the refractory period did happened.

I suspect that if you plot the s value (spikes) you will see that the neuron did spike during the "missing" voltage period in the plot you show here. Please make another run and plot the v and the s and let see if the neuron miss the spike and reset the voltage unexpectedly.

Hi @Hananel-Hazan , I appreciate your help on this. I am just trying to understand the neuron's behavior.

So, I have plotted the 's' onto the voltage plot, and it does seem that those voltages that drop before the threshold are considered threshold spikes.

Can you explain why the spikes occur that have not reached the voltage threshold?

[Hananel-Hazan]

Thank you for following up.
Great, I'm glad to see that the spikes are in the right place!

The reason the voltage plot show that the neuron did not cross the threshold, but spike did omit is base on the LIF forward function that show the following operations:

1. decay the voltage
2. adding input to v ( for all neuron that are not in refractory period)
3. checking if v cross threshold.
4. if 3==yes, reset v, start refractory period, and omit spike

Note that the recorded function that log the v value can only occurs after the execution of the forward method. This means that if the neuron started from a sub-threshold v value and the input caused the neuron to cross the threshold, the neuron will be reset in the forward method and it will not show up on the v plot as you saw in your graphs. Meaning, the plot will not show a v value higher than the threshold, because the recorded function can capture the v neuron only after it been been reset. However, if the input did not cause the neuron to cross the threshold, the v value will continue to increase until it reaches the threshold.

I hope this explanation clarifies the behavioral patterns you see in your graphs.

[rafaelblevin821]

Thank you for following up. Great, I'm glad to see that the spikes are in the right place!

The reason the voltage plot show that the neuron did not cross the threshold, but spike did omit is base on the LIF forward function that show the following operations:

1. decay the voltage
2. adding input to v ( for all neuron that are not in refractory period)
3. checking if v cross threshold.
4. if 3==yes, reset v, start refractory period, and omit spike

Note that the recorded function that log the v value can only occurs after the execution of the forward method. This means that if the neuron started from a sub-threshold v value and the input caused the neuron to cross the threshold, the neuron will be reset in the forward method and it will not show up on the v plot as you saw in your graphs. Meaning, the plot will not show a v value higher than the threshold, because the recorded function can capture the v neuron only after it been been reset. However, if the input did not cause the neuron to cross the threshold, the v value will continue to increase until it reaches the threshold.

I hope this explanation clarifies the behavioral patterns you see in your graphs.

@Hananel-Hazan Thank you for the explanation and for taking the time to reply to my questions.

I am grateful that you are here for support in using BindsNet.