Supervised STDP not updating synaptic weights

[ElisaNguyen]

Hello,
I am currently trying to train a supervised SNN in a similar fashion to the MNIST example (with the voltage clamp) and the learning demo from https://github.com/oshears/adv-ml-2020-snn-project/blob/89da7ed62669f804529d88de5d908d61ff7b6697/documentation/BindsNET_Learning_Demo.ipynb, but on time-series data. I am using the UCI ML dataset about activities of daily living. Here, the data was reshaped to:
[time*input_dimensions] where time refers to the simulation time, chosen as the median duration of the data.
The architecture is also fully connected layers without any hidden layers (Input nodes and LIFNodes as output), where I have as many input nodes as input dimensions n_sensors and as many output nodes as classes.

However, the synaptic weights are unfortunately not updating over the training epochs, and the SNN is predicting the same class all the time. The data is quite imbalanced as well, but I have already used stratified sampling in the train test split. Below is my code, perhaps someone could help me see what is wrong with the training setup.

First, the setup of the network and monitoring variables:

network = Network()

source_layer = Input(n=n_sensors, traces=True, tc_trace=20.0) 
target_layer = LIFNodes(n=n_classes,
                        thresh = -52.0,
                        rest = -70.0,
                        reset = -90.0,
                        refrac = 0,
                        traces=True, 
                        tc_trace=20.0)

#Connect the two layers. nu are the learning rates for presynaptic and postsynaptic spikes
w = torch.rand(source_layer.shape[0], target_layer.shape[0])
connection = Connection(
    source=source_layer, target=target_layer, update_rule=PostPre, nu=(1e-4, 1e-2), w=w
) 

network.add_layer(
    layer=source_layer, name="Input"
)
network.add_layer(
    layer=target_layer, name="Output"
)
network.add_connection(
    connection=connection, source="Input", target="Output"
)

per_class = 1 #how many output neurons per class
labels = torch.empty(1,dtype=torch.int)
spike_record = torch.zeros(1, int(time / dt), n_classes)
assignments = -torch.ones_like(torch.Tensor(n_classes))
proportions = torch.zeros_like(torch.Tensor(n_classes, n_classes))
rates = torch.zeros_like(torch.Tensor(n_classes, n_classes))
layer_monitors = {}
for layer in set(network.layers):
    state_vars = ["s","v"] if (layer != "Input") else ["s"]
    layer_monitors[layer] = Monitor(network.layers[layer], state_vars=state_vars, time=int(time/dt))
    network.add_monitor(layer_monitors[layer], name="%s_spikes" % layer)

weight_history = None
num_correct = 0.0
epochs = 10

Training

train_accs = []
network.train(True)

for step in range(epochs):
    for x, y in zip(X_train, y_train):
        # get the label for the current image
        labels[0] = torch.Tensor([y])

        # randomly decide which output neuron should spike if more than one neuron corresponds to the class
        # choice will always be 0 if there is one neuron per output class
        choice = np.random.choice(per_class, size=1, replace=False)

        # clamp on the output layer forces the node corresponding to the label's class to spike
        # this is necessary in order for the network to learn which neurons correspond to which classes
        # clamp: Mapping of layer names to boolean masks if neurons should be clamped to spiking. 
        # The ``Tensor``s have shape ``[n_neurons]`` or ``[time, n_neurons]``.
        clamp = {"Output": per_class * labels[0] + torch.Tensor(choice).long()} 

        ### Step 1: Run the network with the provided inputs ###
        inputs = {'Inputs': x}
        network.run(inputs=inputs, time=time, clamp=clamp)

        ### Step 2: Get the spikes produced at the output layer ###
        spike_record[0] = layer_monitors["Output"].get("s").view(time, n_classes)
        
        ### Step 3: ###

        # Assign labels to the neurons based on highest average spiking activity.
        # Returns a Tuple of class assignments, per-class spike proportions, and per-class firing rates 
        # Return Type: Tuple[torch.Tensor, torch.Tensor, torch.Tensor]
        assignments, proportions, rates = assign_labels( spike_record, labels, n_classes, rates )

        ### Step 4: Classify data based on the neuron (label) with the highest average spiking activity ###

        # Classify data with the label with highest average spiking activity over all neurons.
        all_activity_pred = all_activity(spike_record, assignments, n_classes)

        ### Step 5: Classify data based on the neuron (label) with the highest average spiking activity
        ###         weighted by class-wise proportion ###
        proportion_pred = proportion_weighting(spike_record, assignments, proportions, n_classes)

        ### Update Accuracy
        num_correct += 1 if (labels.numpy()[0] == all_activity_pred.numpy()[0]) else 0

    train_accuracy = num_correct / ((step + 1) * len(X_train))
    train_accs.append([train_accuracy, step])

Thank you very much for your help!

[petermarathas]

inputs = {'Inputs': x}

I believe the layer is just misspelled here, I think it should be 'Input'.

[ElisaNguyen]

Thank you for catching that! I did not notice as the training ran without error message, just without input apparently. It makes sense that nothing was updated.

[petermarathas]

No problem.