My LSTM model always predicts the same value after fitting, even if I input random numbers. Can anyone help me on this? Thanks!
class LSTM(nn.Module):
     def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(LSTM, self).__init__()
        
        self.output_size = output_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
  
    def forward(self, x):
        batch_size = x.size(0)

        h0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)
        c0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)

        r_out, (hn, cn) = self.lstm(x, (h0, c0))

        output = self.fc(r_out[:,-1,:])

        return output
    
class ToSequence(Data.Dataset):
    
    def __init__(self, features, response, window):
        self.features = features
        self.response = response
        self.window = window

    def __getitem__(self, index):
        x = self.features[index:index+self.window]
        y = self.response[index+self.window-1]
        return x, y

    def __len__(self):
        return len(self.response) - self.window + 1


seq_length = 20
batch_size = 50
num_epochs = 200
learning_rate = 0.1

#Just test a simple sequence data
#use 20 time steps to predict the next data point
df = pd.DataFrame({'A':range(1,40001,1)})
train_y = df.iloc[0:30001,0]
test_y = df.iloc[30001:,0]

train_X = df.iloc[0:30001,0]
test_X = df.iloc[30001:,0]

test_input_features = torch.tensor(test_X.values).resize_((test_X.shape[0],1))  
test_input_response = torch.tensor(test_y.values).resize_((test_y.shape[0],1)) 
test_data_sequence = ToSequence(test_input_features,test_input_response,seq_length)
test_data_loader = Data.DataLoader(test_data_sequence, batch_size)

train_input_features = torch.tensor(train_X.values).resize_((train_X.shape[0],1))  
train_input_response = torch.tensor(train_y.values).resize_((train_y.shape[0],1)) 
train_data_sequence = ToSequence(train_input_features,train_input_response,seq_length)
train_data_loader = Data.DataLoader(train_data_sequence, batch_size)

params = {'input_size': 1,
          'hidden_size': 50,
          'output_size': 1,
          'num_layers': 1}

model = LSTM(**params)

loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) 

for epoch in range(1, num_epochs+1):

    for train_set_X, train_set_Y in train_data_loader: 

        optimizer.zero_grad()
        outputs= model(train_set_X.float())
        loss = loss_function(outputs, train_set_Y.float())
        loss.backward()
        optimizer.step()
    
    if epoch%10 == 0:
        
        print('Epoch: {}/{}.............'.format(epoch, num_epochs), end=' ')
        print("Training MSE: {:.4f}...........".format(loss.item()))

prediction = torch.Tensor()
model.eval()

for X, Y in test_data_loader:

    test_outputs = model(X.float())
    prediction = torch.cat((prediction, test_outputs),0)
    
prediction

The prediction result is the same value for all 10000 test data.