How to generate external stimulation?

[ghost]

Hello,

I would like to implement simple neuron models used for pattern recognition from the paper "Pattern recognition with Spiking Neural Networks: a simple training method". Brief details from the paper http://ceur-ws.org/Vol-1525/paper-21.pdf:
Task: Classify an image as either X or O
Neuron model: Izhikevich neurons
Learning rule: STDP is used as the learning rule for training(BUT here I don't know whether STDP used between all layers or only between input -> hidden)
Network Architecture: 25 input neurons, 5 neurons for the hidden layer and 2 output neurons
If I am not mistaken, only 1000 circle images were trained, then 13 images in the given sequence were tested: {O, O, X, X, O, X, X, X, X, O, O, X, O}

I wanted to implement this, but I had some questions. In the discussion, section authors mentioned that such training is usually tested on the MNIST dataset. Then I decided to do it for the MNIST dataset because my idea was to use bindsnet/examples/mnist/eth_mnist.py as a reference and change there network model

So, I took hidden layer neurons and output neurons = 100, input layer neurons = 784, STDP rule was used between the input → hidden layer only.  And my input layer was made by Input

Izhikevich Model :

class IzhikevichModel(Network):
    '''
    Pattern recognition
    '''
    def __init__(
            self,
            n_inpt:int,
            n_neurons: int = 100,
            dt: float =1.0,
            nu: Optional[Union[float, Sequence[float]]] = (1e-4, 1e-2),
            reduction:Optional[callable] = None,
            wmin: float = 0.0,
            wmax: float = 1.0,
            norm: float = 78.4,
            inpt_shape: Optional[Iterable[int]] = None,
            ) -> None:
        #language =rst
        '''
        params
        '''
        super().__init__(dt = dt)
        self.n_inpt = n_inpt
        self.inpt_shape = inpt_shape
        self.n_neurons = n_neurons
        self.dt = dt

        #Layers
        input_layer = Input(
                n = self.n_inpt, 
                shape = self.inpt_shape,
                traces = True,
                tc_trace = 20.0)
        hid_layer = IzhikevichNodes(
                n = self.n_neurons,
                traces = True,
                rest= -60.0,
                thresh = -45.0,     #Could you check this please?
                tc_trace = 20
                )
        out_layer = IzhikevichNodes(
                n = self.n_neurons,
                traces = True,
                rest = -60.0,
                thresh = -45.0,
                tc_trace = 20)
        #Connections
        #Connection between input -> hid
        w = 0.3*torch.randn(self.n_inpt, self.n_neurons)     #Could you check this please?
        input_hid_conn = Connection(
                source = input_layer,
                target = hid_layer,
                w = w,
                update_rule = PostPre,
                nu = nu,
                reduction = reduction,
                wmin = wmin,
                wmax = wmax,
                norm = norm,
                )
        #Connection hid -> out
        w = 22.5*torch.diag(torch.ones(self.n_neurons))  #this is important, 22.5 stands for lateral inhibition
        hid_out_conn = Connection(
                target = hid_layer,
                source = out_layer,
                w = w,
                wmin = 0,
                wmax = wmax)
        #Add to network
        self.add_layer(input_layer, name ='X')
        self.add_layer(hid_layer, name = 'Hid')
        self.add_layer(out_layer, name = 'Out')
        self.add_connection(input_hid_conn, source = 'X', target = 'Hid')
        self.add_connection(hid_out_conn, source = 'Hid', target = 'Out')        

Question 1: In this paper was not mentioned input data encoders, how can I give my input data to Network? Especially, how to give MNIST dataset?
Question 2: How to implement this part? «After initial tests on the learning ability of the network, the training period was adjusted to be 15s during which the input layer is stimulated every 100ms with a circle pattern. 10ms after stimulating the input layer, the output neuron is given an external stimulation making it to spike. This spiking, in relation to the preliminary spiking of neurons from the input layer, reinforces the paths between activated neurons of the input layer and the trained neuron of the output layer. This training can be seen in the first phase of the time diagrams (top and middle) of Figure 5 from t = 0 to 15s.» Mainly, How to generate external stimulation? 
Question 3: In the above IzhikevichModel input_layer neurons also must be based on the Izhikevich equation, but I couldn’t make 
Question 4: Could you check please IzhikevichModel, have parameters taken correctly?

Any thoughts, suggestions, and examples, feedbacks are highly appreciated.
Thank you

P.S:
As eth_mnist.py was the implementation of the paper Diehl&Cook2015, and they mainly focused on lateral inhibition and adaptive threshold, homeostasis. From my understanding, they showed that STDP cannot do anything alone, because those lateral inhibitions and adaptive threshold leads neurons to compete with each other. BUT in this paper authors did not mention anything like competitive learning, adaptive th, lat. inh.
With the above Izhikevich Model, I got this kind of outputs

[Hananel-Hazan]

Nice paper.

Question 1: In this paper was not mentioned input data encoders, how can I give my input data to Network? Especially, how to give MNIST dataset?

I think that the easy way is to encode the data to a Poisson spikes, your can use the code in eth_mnist.py or any other example.
In the eth_mnist.py line 112 # Load MNIST data the dataset loaded and encoded to a Poisson spikes.

Question 2: How to implement this part? «After initial tests on the learning ability of the network, the training period was adjusted to be 15s during which the input layer is stimulated every 100ms with a circle pattern. 10ms after stimulating the input layer, the output neuron is given an external stimulation making it to spike. This spiking, in relation to the preliminary spiking of neurons from the input layer, reinforces the paths between activated neurons of the input layer and the trained neuron of the output layer. This training can be seen in the first phase of the time diagrams (top and middle) of Figure 5 from t = 0 to 15s.» Mainly, How to generate external stimulation?

You can create your own set of images as input stimulation and feed them to the network.
To generate a external stimulation, there are many ways to do so, the run method of the network can except a external stimulation in two forms, external volt injection or clamping. You can also use the reward modulation part to modulate the STDP as a reward.

Question 3: In the above IzhikevichModel input_layer neurons also must be based on the Izhikevich equation, but I couldn’t make

Sorry, not sure what was the question.

Question 4: Could you check please IzhikevichModel, have parameters taken correctly?

The parameters seems ok, but that is for you to fine tune the the model and find the right parameters.

As eth_mnist.py was the implementation of the paper Diehl&Cook2015, and they mainly focused on lateral inhibition and adaptive threshold, homeostasis. From my understanding, they showed that STDP cannot do anything alone, because those lateral inhibitions and adaptive threshold leads neurons to compete with each other. BUT in this paper authors did not mention anything like competitive learning, adaptive th, lat. inh.

As you mention, both paper work on different assumptions, architecture and principles. The above paper seems to have the ability to change the polarity of the connection, something that Diehl&Cook2015 did not had, also there is no winner take all mechanism in the above paper.

[ghost]

Good day,
Thank you very much @Hananel-Hazan, I will work on generating external stimulus on the output layer with the given ways. But I didn't get clearly this:

The above paper seems to have the ability to change the polarity of the connection, something that Diehl&Cook2015 did not have, ...

About Q3.: Is it possible to create any kind of model without Input? I mean

#Layers
input_layer = Input(
n = self.n_inpt,
shape = self.inpt_shape,
traces = True,
tc_trace = 20.0)
hid_layer = IzhikevichNodes(
n = self.n_neurons,
traces = True,
rest= -60.0,
thresh = -45.0, #Could you check this please?
tc_trace = 20
)

Thank you!

[Hananel-Hazan]

The above paper seems to have the ability to change the polarity of the connection, something that Diehl&Cook2015 did not have, ...

I only skim the paper, but from what I see it seems that the algorithm in the paper can change synapse polarity, similar to what BP does in ANN, in the standard learning method synapse can start with positive value and the algorithm can change it to negative (and vice versa). In the end of the training, neuron can have positive and some negative synapse, something that is not exist in biology (as far as I know). Diehl&Cook2015 have separate inhibitory or excitatory connection, synapse can not change polarity.

About Q3.: Is it possible to create any kind of model without Input? I mean

Yes, since BindsNET version 0.2.7, you can feed the input to any neuron, no need to use 'Input' unit. Let me know how its goes.