djsaunde / spiketorch Goto Github PK

Hi,
As we know that, nowadays, most works of SNN focus on Classification problems. So, do you think if it is possible to solve object detection problem with SNN since we need to solve regression problem in detection part. Thank you very much.

As in BRIAN, I feel that it would be beneficial to discard objects such as LIFGroup and AdaptiveLIFGroup and replace them with a single, generic NeuronGroup. One would pass in n_neurons (as usual), but also arguments giving the equation(s) of the neuronal dynamics (e.g., 'dv/dt = -v') and other pertinent information (e.g., threshold and reset behavior).

The main hurdle is parsing equations into actionable torch.Tensor operations. (sympy)[http://www.sympy.org/en/index.html] has support for converting symbolic mathematics into theano functions. I'm not sure if we can do something similar, but it would certainly be nice to have. If it were possible, this would be a large and time-consuming addition.

Currently, the step() function in the Network class accepts arguments mode, inpts, time. If we are to separate out the training / testing of networks from the object definition, we should be rid of the mode parameter (which gives the train or test phase).

Here's what I'm thinking:

1. Remove the argument mode.
2. Always update Synapses which have STDP "enabled".
3. "Enable" STDP on learnable Synapses during training; disable during test.

The enabling of STDP could be a boolean class-level attribute in a generic Synapse function.

I had an issue with a line of code in groups.py. Specifically, line 96 in groups.py. I was confused as to why it is self.refrac_count[self.s] = dt * self.refractory and not self.refrac_count[self.s] = self.refractory. This is under LIFGroup class and under the "step" function. Why is there a "dt"?

So, we are checking which neurons spiked and the ones that spiked will now have to wait for refractory period to end. I can see that in line 89 you are decrementing the counter by dt per time step which makes sense therefore, why is setting it not simply what I mentioned above?

Another question is for line self.x[self.s.byte()] = 1.0 on line 104. Looking at the documentation for "byte()", it mentions that it is to cast tensor to byte type. Why are we casting it to byte? This way of picking elements usually has a boolean array when calling it. So I thought it should be `self.x[self.s] since self.s is an array of booleans.

Certain constructors and functions should implement type checking, to avoid difficult-to-undestand errors that would be thrown otherwise. This seems like a good implementation. For example, we might use function decorators to implement this as follows:

@accepts(NeuronGroup, dict, str, float)
def step(self, inpts, mode, dt):
        ...