logistic regressionを用いたモデルのaccuracyをあげたい

Question

pytorchベースのlogisticregressionをモデルにしたニューラルネットを作成したのですが，その精度が常に20パーセント台す．
精度が低いので直したいです．入力x[1,64]の配列なのでinput_sizeは64にしました．ラベルyは[1,6]配列です．
色々調べて，logisticregressionはsoftmaxを通す必要がないと書かれたいたのでsoftmaxを通していないです．
バッチサイズを10くらいにしてから，スケールアップしようと思ったのですが，常に20パーセント台です．精度が低すぎるのはハイパラメータの問題でしょうか？それとも他の問題でしょうか？どなたか，ご教示の程お願い致します．また，bindsnet[1]というライブラリーを使用しています．
[1] Bindsnet: https://bindsnet-docs.readthedocs.io/
##コード

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.loaders import poisson_loader
# モデルの定義
class LogisticRegression(nn.Module):
    def __init__(self, input_size, num_classes):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes)
    def forward(self, x):
        output = self.linear(x)
        return output


network = Network(dt=1.0)
input_size = 64
num_classes = 6
time = 32      
_BATCH_SIZE = 300
num_epochs = 100

inpt = Input(64, shape=(1,64))
output = LIFNodes(64, thresh=-52 + torch.randn(64))  # m1のb
network.add_layer(inpt, name='A')
network.add_layer(output, name='E')
network.add_connection(Connection(inpt, output, w=torch.randn(inpt.n, output.n)), 'A', 'E')
network.add_connection(Connection(output, output, w=0.5*torch.randn(output.n, output.n)), 'E', 'E')

spikes = {}
for l in network.layers:
    spikes[l] = Monitor(network.layers[l], state_vars=["s"], time=time)
    network.add_monitor(spikes[l], name="%s_spikes" % l)
voltages = {"E": Monitor(network.layers["E"], ["v"], time=time)}
network.add_monitor(voltages["E"], name="E_voltages")

npzfile = np.load("C:/Users/name/Desktop/myo-python-1.0.4/myo-armband-nn-master/data/train_set.npz")
x = npzfile['x']
y = npzfile['y']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.33, random_state=42)
# 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=1000)
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=1000)
loader = zip(poisson_loader(x_train * 0.64, time=64), iter(y_train))
training_pairs = []
for i, (datum, y_train) in enumerate(loader):
    network.run(inputs={"A": datum}, time=time, input_time_dim=1)
    training_pairs.append([spikes['E'].get('s').sum(0), y_train])
    network.reset_state_variables()
    if (i + 1) % 1 == 0: print('Train progress: (%d / 40)' % (i + 1))
    if (i + 1) == 40: print(); break

model = LogisticRegression(input_size, num_classes); criterion = nn.CrossEntropyLoss()   # m2に相当
optimizer = torch.optim.SGD(model.parameters(), lr=0.005)
# スパイクとラベルのトレーニング
correct, total = 0, 0
for epoch in range(num_epochs):
    for i, (s, y_train) in enumerate(training_pairs):
        optimizer.zero_grad()
        output = model(s.float())
        y_train = torch.reshape(y_train, (-1,))  # y_trainのサイズを[1], output=[1.6]
        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()
        _, predicted = torch.max(output, 1)
        total += y_train.size(0)
        correct += int(predicted == y_train.long())
print('Accuracy of logistic regression on train examples: %2f %%\n ' % (100 * correct / total))


loader = zip(poisson_loader(x_test * 0.64, time=64), iter(y_test))
test_pairs = []
model.eval()
for i, (datum, y_test) in enumerate(loader):
    network.run(inputs={"A": datum}, time=time, input_time_dim=1)
    test_pairs.append([spikes['E'].get('s').sum(0), y_test])
    network.reset_state_variables()
    if (i + 1) % 100 == 0: print('Test progress: (%d / 500)' % (i + 1))
    if (i + 1) == 500: print(); break


correct, total = 0, 0
for s, y_test in test_pairs:
    output = model(s.float()); _, predicted = torch.max(output, 1)
    y_test = torch.argmax(y_test)
    total += 1
    correct += int(predicted == y_test)
print('Accuracy of logistic regression on test examples: %2f %%\n ' % (100 * correct / total))