I created a neural network using the logistic regression implemented by pytorch as a model, but the accuracy is low.
I want to know the cause. So Where should I check ?
import torch
import torch.nn as nn
import numpy as np
from bindsnet.network import Network
from bindsnet.network.nodes import Input, LIFNodes
from bindsnet.network.topology import Connection
from bindsnet.network.monitors import Monitor
from sklearn.model_selection import train_test_split
from bindsnet.encoding import poisson_loader
import matplotlib.pyplot as plt
# difine of model
class LogisticRegression(nn.Module):
    def __init__(self, input_size, num_classes):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes)
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = x.view(-1, 64)
        return self.linear(x)
network = Network(dt=1.0)
input_size = 64
num_classes = 6
time = 64      
num_epochs = 10
network = Network(dt=1.0)
_BATCH_SIZE = 300

inpt = Input(64, shape=(1,64)); network.add_layer(inpt, name='A')
middle = LIFNodes(900, thresh=-52 + torch.randn(900)); network.add_layer(middle, name='B')
center = LIFNodes(900, thresh=-52 + torch.randn(900)); network.add_layer(center, name='C')
final = LIFNodes(900, thresh=-52 + torch.randn(900)); network.add_layer(final, name='D')
output = LIFNodes(6, thresh=-52 + torch.randn(6)); network.add_layer(output, name='E')

network.add_connection(Connection(inpt, middle, w=torch.randn(inpt.n, middle.n)), 'A', 'B')
network.add_connection(Connection(middle, center, w=torch.randn(middle.n, center.n)), 'B', 'C')
network.add_connection(Connection(center, final, w=torch.randn(center.n, final.n)), 'C', 'D')
network.add_connection(Connection(final, output, w=torch.randn(final.n, output.n)), 'D', 'E')
network.add_connection(Connection(output, output, w=torch.randn(output.n, output.n)), 'E', 'E')

inpt_monitor = Monitor(obj=inpt, state_vars=("s", "v"), time=500,)
middle_monitor = Monitor(obj=inpt, state_vars=("s", "v"), time=500,)
center_monitor = Monitor(obj=inpt, state_vars=("s", "v"), time=500,)
final_monitor = Monitor(obj=inpt, state_vars=("s", "v"), time=500,)
out_monitor = Monitor(obj=inpt, state_vars=("s", "v"), time=500,)

# connecting Monitor to network
network.add_monitor(monitor=inpt_monitor, name="A")
network.add_monitor(monitor=middle_monitor, name="B")
network.add_monitor(monitor=center_monitor, name="C")
network.add_monitor(monitor=final_monitor, name="D")
network.add_monitor(monitor=out_monitor, name="E")

for l in network.layers:
    m = Monitor(network.layers[l], state_vars=['s'], time=time)
    network.add_monitor(m, name=l)


npzfile = np.load("C:/Users/tazawa/Desktop/myo-python-1.0.4/myo-armband-nn-master/data/train_set.npz")
x = npzfile['x']
y = npzfile['y']
x_train, x_test = train_test_split(x, test_size=0.3)
y_train, y_test = train_test_split(y,test_size=0.3)
# converting tensor
x_train = torch.from_numpy(x_train).float()
y_train = torch.from_numpy(y_train).float()
x_train = torch.clamp(x_train,min=0,max=100)
loader = zip(poisson_loader(x_train * 0.20, time=20), iter(y_train))

training_pairs = []
for i, (datum, y_train) in enumerate(loader):
    inputs = {'A': datum.repeat(time, 1), 'E_b': torch.ones(time, 1)}
    network.run(inputs=inputs, time=time)
    #network.run(inputs={'A':datum}, time=250)
    training_pairs.append([network.monitors['E'].get('s').sum(-1), y_train])
    network.reset_state_variables()
    if (i + 1) % 500 == 0: print('Train progress: (%d / 10000)' % (i + 1)) 
    if (i + 1) == 10000: print(); break

    model = LogisticRegression(input_size, num_classes); criterion = nn.CrossEntropyLoss()   
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
# training spikes and labels
for epoch in range(num_epochs):
    for i, (s, y_train) in enumerate(training_pairs):
        optimizer.zero_grad(); output = model(s.float().softmax(0))
        y = torch.reshape(y_train, (-1,))
        y_train = y_train.view(-1, 6)
        y_train = torch.argmax(y_train, dim=-1)
        loss = criterion(output,  y_train.long())
        loss.backward(); optimizer.step()

x_test = torch.from_numpy(x_test).float()
y_test = torch.from_numpy(y_test).long()
x_test = torch.clamp(x_test,min=0,max=100)
loader = zip(poisson_loader(x_test * 0.20, time=20), iter(y_test))
test_pairs = []
model.eval()
for i, (datum, y_test) in enumerate(loader):
    inputs = {'A': datum.repeat(time, 1), 'E_b': torch.ones(time, 1)}
    network.run(inputs=inputs, time=time)
    test_pairs.append([network.monitors['E'].get('s').sum(-1), y_test])
    network.reset_state_variables()

    if (i + 1) % 500 == 0: print('Test progress: (%d / 1000)' % (i + 1))
    if (i + 1) == 1000: print(); break

correct, total = 0, 0
for s, y_test in test_pairs:
    output = model(s.float().softmax(0)); _, predicted = torch.max(output.data.softmax(0), 1)
    total += 1
    y_test = torch.argmax(y_test, dim=-1)
    correct += int(predicted == y_test.long())
    accuracy = 100 * correct / total
    print('Accuracy of logistic regression on test examples: %2f %%\n ' % (100 * correct / total))
    print("Iteration: {}. Loss: {}. Accuracy: {}.".format(iter, loss.item(), accuracy))