Huge drop of classification accuracy on loihi board/loihi simulation compared to slayer classifcation

[gwgknudayanga]

Hi,

I trained the following network in slayer for nmnist event data classification. In this case I use the last layer's neuron voltages as the logit as shown in training part. It gave a 96 % test accuracy. Then i export this to lava and run on loihi and loihi cpu simulation and evaluated the test set. However then the test accuracy was about 55% which is 40% drop compared to slayer classification.
When i checked the voltage outputs of the output layer after 32 time steps these are outputs are different from slayer's output.
Could you please help to resolve this issue?

neuron_conv_params = {
'threshold' : 1.0,
'current_decay' : 1.0,
'voltage_decay' : 0.03,
'requires_grad' : False,
'persistent_state' : False,
}

neuron_output_layer_params = {
            'threshold'     : 2048.0,
            'current_decay' : 1.0,
            'voltage_decay' : 0.03,
            'requires_grad' : False,
            'persistent_state' : True,
    }

neuron_conv_kwargs = {**neuron_conv_params, 'norm': slayer.neuron.norm.MeanOnlyBatchNorm}

quantizer = _quantize_8bit #netx_quantizer #_quantize_8bit

block_kwargs = dict(weight_norm=False, delay_shift=False ,pre_hook_fx=quantizer)
synapse_kwargs = dict(weight_norm=False,pre_hook_fx=quantizer)

net_ladl = nn.Sequential(
    slayer.block.cuba.Conv(neuron_conv_kwargs,2,16,kernel_size=3, stride=2, padding=1,**block_kwargs),
    slayer.block.cuba.Conv(neuron_conv_kwargs,16,32,kernel_size=3, stride=2, padding=1,**block_kwargs),
    slayer.block.cuba.Conv(neuron_conv_kwargs,32,64,kernel_size=3, stride=2, padding=1,**block_kwargs),
    slayer.block.cuba.Conv(neuron_conv_kwargs,64,16,kernel_size=3, stride=1, padding=1,**block_kwargs),
    slayer.block.cuba.Conv(neuron_output_layer_params,16,num_output,kernel_size=1, stride=1, padding=0,**block_kwargs),
)

net_ladl = net_ladl.to(device)
H, W = (34,34)
N, C, T = 32, 2, 31
input = torch.rand(N, C, H, W, T)
net_ladl(input.to(device=device))

test_loader2 = DataLoader(dataset=testing_set, batch_size=1, shuffle=False)

with torch.no_grad():

    test_all_samples = 0
    test_correct_samples = 0

    for i,(input,label) in enumerate(test_loader2):
        input = input.to(device)
        label = label.to(device)

        #Here expect NXT for lavaa
        #Here slayer and lava expect NXT format
        #output = net(input.permute(4,0,1,2,3))
        #output = torch.sum(output,dim=0)
        #output = torch.argmax(output,dim=-1)
        output = net_ladl(input) #Here the output is "fixed-point"
        temp = net_ladl[4].neuron.voltage_state
        output = torch.sum(temp,(2,3))
        #output = torch.sum(output,(2,3)) 
        #sum over spatial dimensions, sum over time dimension, then argmax over output dimension, finally remain with (element_in_batch,predicted class)
        
        #output = torch.sum(output,dim=-1)
        output = torch.argmax(output,dim=-1)

        net_ladl[4].neuron.voltage_state.data = torch.zeros_like(net_ladl[4].neuron.voltage_state)

        batch_samples = output.shape[0]

        batch_correct_samples =  torch.sum(output == label).cpu().data.item()

        test_all_samples += batch_samples
        test_correct_samples += batch_correct_samples 

        #print("current test accuracy {:.4f}".format(test_correct_samples / test_all_samples))

        functional.reset_net(net)

    test_acc = test_correct_samples / test_all_samples
    print("test accuracy 333 ",test_acc)

print("export hdf5 ")
device_cpu = torch.device('cpu')
net_ladl = net_ladl.to(device_cpu)
output_path = os.path.join("/media/atiye/Data/Udaya_Research_stuff/to_lava_code/nmnist/hdf5_net_outputs/","nmnist_mean_only_final_voltage_state_2048.net")
export_hdf5(net_ladl,output_path,skip_last_synapse_only_layer=False)
print("finish exporting to ",output_path)

Best Rgds,
Udayanga