LSTM предсказывает одно и то же значение.

Я реализую в PyTorch модель LSTM для предсказания, увеличится или уменьшится закрывающая стоимость акции через 5 и 10 минут. Конкретно, я использую 24 года данных с интервалом в 5 минут с 19 признаками, разделенных на блоки по одной неделе на прогноз (используя 7 различных акций). Проблема, с которой я столкнулся, заключается в том, что, как ни старайся, модель LSTM, похоже, предсказывает значения вокруг одного определенного значения, чтобы всегда минимизировать потерю, что не снижается слишком сильно.

Я предварительно подготавливаю входные данные и цели в torch.tensors с размерностью [batch_size, sequence_len, features] (в моем случае это [32, 2016, 19]), нормализую их между 0 и 1 и подаю в мою модель LSTM, которая структурирована следующим образом:

class MultiInputOutputLSTM(nn.Module):
  def __init__(self, input_size, hidden_size, num_layers, output_size, dropout, lr, batch_size):
    super(MultiInputOutputLSTM, self).__init__()
    self.input_size = input_size
    self.hidden_size = hidden_size
    self.num_layers = num_layers
    self.dropout = dropout
    self.batch_size = batch_size
    self.loss_list = []
    self.accuracy = 0
    self.predictions_list = [0]

    self.lstm = nn.LSTM(input_size = self.input_size, hidden_size = self.hidden_size, num_layers = self.num_layers, dropout = self.dropout,  batch_first=True)
    self.fc = nn.Linear(hidden_size, output_size, bias=True)
    self.sigmoid = nn.Sigmoid()
    self.criterion = nn.BCEWithLogitsLoss()
    self.optimizer = torch.optim.RMSprop(self.parameters(), lr = lr, alpha=0.9, weight_decay=1e-4,  momentum=0.5)
    self.scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, 'min')

  def forward(self, x):

    h0 = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)
    c0 = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)
    lstm_out, _ = self.lstm(x, (h0, c0))
    output = self.fc(lstm_out[:, -1, :])

    return output

  def train_step(self ,x, y):
        self.train()
        predictions_1 = torch.round(self.forward(x))
        predictions = self.forward(x)
        if (predictions_1.detach().cpu().numpy()[0] == y.detach().cpu().numpy()[0]).all():
          self.accuracy += 1
        self.predictions_list.append(predictions.detach().cpu().numpy()[0][0])
        penalty = torch.mean((predictions-0.5)**2)
        loss = self.criterion(predictions, y) + penalty
        self.scheduler.step(loss)
        self.optimizer.zero_grad()
        self.loss_list.append(loss.item())
        mean_loss = sum(self.loss_list)/len(self.loss_list)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.parameters(), max_norm=6)
        self.optimizer.step()
        return loss.item(), mean_loss, self.accuracy, predictions.detach().cpu().numpy()[0], y.detach().cpu().numpy()[0]

Цели равны 1, если цена растет, 0 в противном случае.
Гиперпараметры такие:

input_size = 19
hidden_size = 3
num_layers = 5
output_size = 2
lr = 0.001
num_epochs = 5
batch_size = 32
dropout = 0.3

Сначала я создаю dataframe из CSV файла: затем я делю его на цели и входные данные, и с последними вычисляю различные торговые сигналы.
Затем я преобразую данные в подходящий вид для модели LSTM, разделяя их на недельные блоки.

Модель должна предсказывать значения, близкие к единице, если цена растет, и близкие к нулю, если цена остается неизменной/снижается: однако, она создает одно предсказание и затем постепенно снижается к отметке 0.5, оставаясь на месте до конца процесса обучения. Разделение на обучающую и тестовую выборки составляет 85-15%.

Вот список того, что я пробовал: уменьшение или увеличение скорости обучения (от 0.00001 до 0.1), размера выхода (с большим и меньшим количеством прогнозов), batch_size (от 1 до 256), num_layers (от 1 до 5), input_size (с 1, 2, 3… 19 признаками), dropout (от 0 до 0.7) и num_epochs (от 1 до 100).

Я пробовал Adam оптимизатор, затем SDG, затем RMSProp оптимизатор, изменяя alpha, momentum и weight_decay.
Я пробовал менять входные данные, чтобы лучше соответствовать целям (заменяя каждый элемент на 0 и 1: 1, если элемент больше предыдущего, 0 в противном случае) или использовать приросты между элементами.

Также пробовал BCELoss (с слоем активации sigmoid в self.forward()), L1Loss, MSELoss, CrossEntropyLoss, и даже регулировал потери, добавляя штраф penalty = torch.mean((y-predictions)**(-2)), но это ничего не изменило, значения все равно колеблются вокруг 0.5. Средняя потеря снижается с 1.174 до 1.040.
Сейчас я пытаюсь сильно штрафовать значения вокруг 0.5 с помощью penalty = torch.mean((predictions-0.5)**(-2)), но предсказания идут в одном направлении и остаются около 0 или 1, не обучаясь.

Что я могу сделать, чтобы решить эти проблемы? (кто-то предложил, что это может быть исчезающий градиент, но я действительно не знаю, как решить эту проблему)