Modifying PostPre (STDP) update rule

[vexing-shusher]

Hello to everyone here. The question may seem obvious for some more experienced users of this library (and SNNs in general), but I struggled a lot to find a solution myself and was unable to succeed.

General STDP update rule is formulated as follows:

dW = f(w) * exp(-dt/T), where dt is time difference between post- and pre- spikes. As far as I am concerned, in BindsNET this rule is implemented in a different manner but does the same thing (correct me if I am wrong).

Now let's consider a slightly different update rule, e.g. dW = f(W) *exp[ - (dt/T)^2] (just to illustrate, nothing meaningful). dt here is the time difference between the last pos-t and the last pre-spikes.

How should I tweak the code to achieve that? Where to look? Or is it even possible without rewriting the whole structure (node-connection-network)?

Thanks in advance.

[SimonInParis]

Hi.
Bindsnet implements the STDP exactly as you described, with some speed-ups.
If you want to try with a modified STDP rule, you can either cut/paste the PostPre() class and make a new one in a new branch, or overload the update() funciton from this class.
In your case (exp(-dt^2)), you can also try to overload/modify the compute_decays() function in the Nodes class (nodes.py):

def compute_decays(self, dt) -> None:
        # language=rst
        """
        Abstract base class method for setting decays.
        """
        self.dt = torch.tensor(dt)
        if self.traces:
            self.trace_decay = torch.exp(
                -self.dt / self.tc_trace
            )  # Spike trace decay (per timestep).

or later in the forward function:

    @abstractmethod
    def forward(self, x: torch.Tensor) -> None:
        # language=rst
        """
        Abstract base class method for a single simulation step.
        :param x: Inputs to the layer.
        """
        if self.traces:
            # Decay and set spike traces.
            self.x *= self.trace_decay

            if self.traces_additive:
                self.x += self.trace_scale * self.s.float()
            else:
                self.x.masked_fill_(self.s.bool(), 1)

        if self.sum_input:
            # Add current input to running sum.
            self.summed += x.float()

and modify the decaying rule to suit your needs (faster decay in your case).

You can also overload this function just for a modified neuron type of your own. Up to you.

But surely, we would gladly hear about the motivation behind this idea!

Simon

[vexing-shusher]

Thank you! The plan is to implement specific experimental curves that arise while working with memristors. If everything works out, I hope a paper on the subject will be coming soon :)