Switched "zero" and "subtract"

[Act862]

Greetings,

I believe that the two reset_mechanisms are switched when stated inside the snn.Leaky() constructor. When I create the leaky neuron as:
lif = snn.Leaky(beta=0.8, reset_mechanism="zero")

the output is:

and when I create the neuron as: lif = snn.Leaky(beta=0.8, reset_mechanism="subtract")

the outputs do not agree with the implementation in: https://www.youtube.com/watch?v=aUjWRpisRRg

[xli562]

TL;DR: I think this is not a bug.

What I did:

1. Consult ChatGPT
2. Read lapicque.py, leaky.py and neurons.py
3. Tweak leaky.py

First of all, Lapicque acts as expected, resetting to zero when reset_mechanism='zero' and subtracting the threshold when reset_mechanism='subtract'. So I compared Leaky to Lapicque. I did not spot a bug. All correspondences and calculations are correct.

Then I noticed that Leaky has an argument reset_delay that defaults to True. Lapicque does not have this argument.

I set reset_delay=False in Leaky, and it does everything correctly.

Furthermore, ChatGPT says that the seemingly swapped resetting behaviours of Leaky is due to this, as mentioned in Tutorial 3:

equation (10) has been time-shifted back one step without loss of generality.

When reset_mechanism='zero' for Leaky, the membrane potential (mem) is reset to zero, but then it immediately does another integration, which increases mem.

I think this sort of makes sense. At least I am convinced.

Reference:

This is where a reset is calculated. Note how the return line is different. Leaky sort of 'does one more iteration' before returning.

• Lapicque

def _base_state_function(self, input_):
    base_fn = (
        input_ * self.R * (1 / (self.R * self.C)) * self.time_step
        + (1 - (self.time_step / (self.R * self.C))) * self.mem
    )
    return base_fn

def _base_sub(self, input_):
    return self._base_state_function(input_) - self.reset * self.threshold

def _base_zero(self, input_):
    return self._base_state_function(
        input_
    ) - self.reset * self._base_state_function(input_)

• Leaky

def _base_state_function(self, input_):
    base_fn = self.beta.clamp(0, 1) * self.mem + input_
    return base_fn

def _base_sub(self, input_):
    return self._base_state_function(input_) - self.reset * self.threshold

def _base_zero(self, input_):
    self.mem = (1 - self.reset) * self.mem
    return self._base_state_function(input_)

[DoubleGio]

So I've raised this issue in #379 and attempted to fix it, but having a closer look at there's two issues that cause this discrepancy/confusion.
@xli562 I would argue this is a bug, or at the very least there are differences between formulation and implementation that ought to be cleared up.

• Missing $\beta$ in Soft Reset: Tutorial 3 defines a soft reset as:
  $U[t+1] = \beta U[t] + WX[t+1] + \beta S[t]U_{\rm thr}$.
  This softer reset formulation produces the expected behaviour, however, the documentation and paper do not include $\beta$ before the reset:
  $U[t+1] = \beta U[t] + WX[t+1] + S[t]U_{\rm thr}$.
  This is how it's currently implemented and why it so closely (but not exactly) resembles a reset to 0.
  I couldn't find an earlier version of snnTorch where the Leaky neuron implemented the softer reset -- @jeshraghian is this a mistake or on purpose (and are tutorial 3 and the linked video outdated)?
• Differences in when the input is applied in the Hard Reset: changing reset_delay to False should only change S[t] into S[t+1] and should not affect the order in which operations are carried out.
  This works for the soft reset -- changing it to false does not produce the expected output for me.
  This is bugged for the hard reset however, which with reset_delay=True mistakenly applies the reset first and adds the input after, which is inconsistent with every formulation of this reset mechanism I could find.
  Earlier versions of snnTorch implemented the hard reset properly so that's definitely a bug.

I'd argue for something like:

def _base_state_function(self, input_):
    return self.beta.clamp(0, 1) * self.mem + input_

def _base_sub(self, input_): # soft reset
    base_fn = self._base_state_function(input_) 
    return base_fn - self.reset * self.threshold

def _base_soft_sub(self, input_): # new? softer reset
    base_fn = self._base_state_function(input_) 
    return base_fn - self.reset * self.threshold * self.beta.clamp(0, 1)

def _base_zero(self, input_): # fixed hard reset
    base_fn = self._base_state_function(input_)
    return base_fn - self.reset * base_fn