Hello All,
I am building an LSTM based classifier for EEG motor imagery Data for 2 classes. The data is from a 64 channel EEG and each channel has 20000 data points. The model is being trained for 50 epochs and converges for a decent loss. While testing the model for an individual file, the Sigmoid outputs only negative value irrespective of the class. Please tell me where could I be going wrong. Sorry for a trivial question, I am relatively new to the field and recently shifted to Pytorch
Attaching my code below

class pytorch_lstm(net.Module):
    def __init__(self, features, hidden_size, sequence_length, loss_function='BCE'):
        super(pytorch_lstm, self).__init__()
        self.loss = loss_function
        self.features = features
        self.hidden_size = hidden_size
        self.seq_length = sequence_length
        self.lstm = net.LSTM(
            input_size=self.features,
            hidden_size=hidden_size,
            num_layers=1,
            batch_first=True
        )
        self.linear = net.Linear(self.hidden_size * self.seq_length, 1)

    def init_Hidden(self):
        hidden_state = torch.zeros(1, 1, self.hidden_size).cuda()
        cell_state = torch.zeros(1, 1, self.hidden_size).cuda()
        self.hidden = (hidden_state, cell_state)

    def forward(self, X):
        lstm_out, self.hidden = self.lstm(X, self.hidden)
        out = lstm_out.contiguous().view(1, -1)
        out = self.linear(out)
        return out

    def train_model(self, model, dataloader, num_epochs):
        least_loss = 10
        model.train()
        if self.loss == 'BCE':
            self.criterion = net.BCEWithLogitsLoss().cuda()
        elif self.loss == 'MSE':
            self.criterion = net.MSELoss().cuda()
        else:
            raise ValueError('PROVIDE A VALID LOSS FUNCTION')

        optimizer = torch.optim.Adam(model.parameters())
        training_loss = []
        for i in range(num_epochs):
            optimizer.zero_grad()
            st = time.time()
            epoch_loss = 0
            for _, (x, y) in enumerate(dataloader):
                model.init_Hidden()
                output = model(x)
                loss = self.criterion(output.view(-1), y)
                loss.backward()
                optimizer.step()
                print(loss.item())
                epoch_loss += loss.item()
            et = time.time()
            avg_loss = epoch_loss / 438
            print('----------------------------------------------------------')
            print('\033[1m' + 'TOTAL_TIME_PER_EPOCH = ' + str(et - st) + '\033[1m')
            print('\033[1m' + 'AVERAGE_LOSS = ' + str(avg_loss) + '\033[1m')
            training_loss.append(avg_loss)
            if avg_loss<least_loss:
                torch.save(model.state_dict(), 'path' + self.loss +'.pth')
                least_loss = avg_loss

        plt.plot(training_loss)
        plt.xlabel('EPOCHS')
        plt.ylabel('LOSS')
        plt.show()

The model outputs something like -
tensor([[-0.0545]], device='cuda:0') CLASS 1
tensor([[-0.0541]], device='cuda:0') CLASS 2
tensor([[-0.0522]], device='cuda:0') CLASS 1

Interestingly, the sigmoid outputs are quite close, Can someone please tell me why ?
Thanks in Advance