Почему мой LSTM не может определить, является ли последовательность нечетной или четной по количеству единиц? ⇐ Python

[Anonymous]

Я пытаюсь понять LSTM и хочу реализовать простой пример классификации последовательности как «0», если число «1» в последовательности нечетное, и как «1», если число «1» четное. . Это моя процедура генерации данных и обучения:

Код: Выделить всё

import torch
import numpy as np
from torch.utils.data import DataLoader
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

from Dataset import LSTMDataset # Custom Dataset
from Network import LSTMNet # Custom Network

if __name__ == "__main__":

numSamples = 1000
sampleLength = 5

samples = np.ndarray( shape=( numSamples, sampleLength ), dtype=np.float32 )
labels = np.ndarray( shape=( numSamples ), dtype=np.float32 )
for s in range( numSamples ):
sample = np.random.choice( [ 0, 1 ], size=sampleLength )
samples[ s ] = sample
even = np.count_nonzero( sample == 1 ) % 2 == 0
labels[ s ] = int( even )

X_train, X_test, y_train, y_test = train_test_split( samples, labels, test_size=0.25, random_state=42 )

trainingSet = LSTMDataset( X_train, y_train )
testSet = LSTMDataset( X_test, y_test )

training_loader = DataLoader( trainingSet, batch_size=1, shuffle=True )
validation_loader = DataLoader( testSet, batch_size=1, shuffle=False )

model = LSTMNet( inputSize= sampleLength )
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
loss_fn = torch.nn.BCELoss()

for epoch in range( 10 ):
yPredicted = []
yTruth = []
for i, data in enumerate( training_loader ):
inputs, labels = data

optimizer.zero_grad()

outputs = model(inputs)

loss = loss_fn(outputs, labels)
loss.backward()

optimizer.step()

yTruth.append( int( labels.item() ) )
yPredicted.append( int( torch.round( outputs ).item() ) )

accuracy = accuracy_score( yTruth, yPredicted )
print( f"Accuracy: {accuracy:.2f}" )

Мой набор данных и сеть:

Код: Выделить всё

class LSTMDataset( Dataset ):
def __init__( self, x, y ):
self.x = x
self.y = y

def __len__(self):
return self.y.shape[ 0 ]

def __getitem__(self, idx):
sample, label = self.x[ idx ], self.y[ idx ]
return sample.reshape( ( -1, 1 ) ), label.reshape( ( 1 ) )

class LSTMNet( nn.Module ):
def __init__( self, sequenceLength ):
super().__init__()
self.hidden_size = 10
self.lstm = nn.LSTM( input_size=1, hidden_size=self.hidden_size, num_layers=2, batch_first=True )
self.net = nn.Sequential(
nn.Flatten(),
nn.ReLU(),
nn.Linear( sequenceLength * self.hidden_size, 1 ),
nn.Sigmoid()
)

def forward(self, x):
x, _ = self.lstm( x )
x = self.net( x )
return x

Но, к сожалению, точность моих тренировок никогда не выходит за пределы 53%. Есть ли у кого-нибудь подсказки, что я делаю неправильно?
Входная форма моей сети — ( 1, 5, 1 ), и я хотел передать элементы последовательности один за другим другой в мою сеть, поэтому я выбрал ( 1, 5, 1 ), а не (1, 1, 5 ).

Подробнее здесь: https://stackoverflow.com/questions/790 ... er-of-ones