почему MSE на тестовом наборе очень низкий и, кажется, не развивается (не увеличивается после увеличения эпох) - PullRequest
Новая
       47

почему MSE на тестовом наборе очень низкий и, кажется, не развивается (не увеличивается после увеличения эпох)

0 голосов
/ 11 февраля 2019

Я работаю над проблемой прогнозирования стоимости акций с использованием LSTM.

Моя работа основана на следующем проекте .Я использую набор данных (временные ряды цен на акции) общей длины 12075, который я разделил на поезд и набор тестов (почти 10%).Это то же самое, что и в ссылочном проекте.

train_data.shape (11000,)

test_data.shape (1075,) enter image description here

В нашей модели мы начинаем с обучения модели lstm «многие ко многим», где мы предоставляем N последовательностей входных данных (цены акций) и N последовательностей меток (которые выбираются путем упорядочивания данных train_data по N сегментам в качестве входных данных иметки выбираются как следующая последовательность значений входов).

Затем мы начинаем прогнозировать каждое значение отдельно и предоставляем его в качестве входных данных в следующий раз, пока не достигнем предсказания num_predictions.

Потеря - это просто MSE между прогнозируемыми значениями и фактическими значениями.

Предсказания в конце кажутся неплохими.Однако я просто не понимаю, почему ошибка обучения резко уменьшается, а ошибка теста всегда очень и очень мала (хотя она продолжает уменьшаться очень мало).Я знаю, что обычно ошибка теста должна начать увеличиваться после некоторого количества эпох из-за переоснащения.Я протестировал более простой код и другой набор данных, и я столкнулся с относительно похожими графиками MSE.

Вот мой цикл гривы: 

for ep in range(epochs):

# ========================= Training =====================================
for step in range(num_batches):

    u_data, u_labels = data_gen.unroll_batches()

    feed_dict = {}
    for ui,(dat,lbl) in enumerate(zip(u_data,u_labels)):
        feed_dict[train_inputs[ui]] = dat.reshape(-1,1)
        feed_dict[train_outputs[ui]] = lbl.reshape(-1,1)

    feed_dict.update({tf_learning_rate: 0.0001, tf_min_learning_rate:0.000001})

    _, l = session.run([optimizer, loss], feed_dict=feed_dict)

    average_loss += l

# ============================ Validation ==============================
if (ep+1) % valid_summary == 0:

  average_loss = average_loss/(valid_summary*num_batches)

  # The average loss
  if (ep+1)%valid_summary==0:
    print('Average loss at step %d: %f' % (ep+1, average_loss))

  train_mse_ot.append(average_loss)

  average_loss = 0 # reset loss

  predictions_seq = []

  mse_test_loss_seq = []

  # ===================== Updating State and Making Predicitons ========================
  for w_i in test_points_seq:
    mse_test_loss = 0.0
    our_predictions = []

    if (ep+1)-valid_summary==0:
      # Only calculate x_axis values in the first validation epoch
      x_axis=[]

    # Feed in the recent past behavior of stock prices
    # to make predictions from that point onwards
    for tr_i in range(w_i-num_unrollings+1,w_i-1):
      current_price = all_mid_data[tr_i]
      feed_dict[sample_inputs] = np.array(current_price).reshape(1,1)
      _ = session.run(sample_prediction,feed_dict=feed_dict)

    feed_dict = {}

    current_price = all_mid_data[w_i-1]

    feed_dict[sample_inputs] = np.array(current_price).reshape(1,1)

    # Make predictions for this many steps
    # Each prediction uses previous prediciton as it's current input
    for pred_i in range(n_predict_once):

      pred = session.run(sample_prediction,feed_dict=feed_dict)

      our_predictions.append(np.asscalar(pred))

      feed_dict[sample_inputs] = np.asarray(pred).reshape(-1,1)

      if (ep+1)-valid_summary==0:
        # Only calculate x_axis values in the first validation epoch
        x_axis.append(w_i+pred_i)

      mse_test_loss += 0.5*(pred-all_mid_data[w_i+pred_i])**2

    session.run(reset_sample_states)

    predictions_seq.append(np.array(our_predictions))

    mse_test_loss /= n_predict_once
    mse_test_loss_seq.append(mse_test_loss)

    if (ep+1)-valid_summary==0:
      x_axis_seq.append(x_axis)

  current_test_mse = np.mean(mse_test_loss_seq)

  # Learning rate decay logic
  if len(test_mse_ot)>0 and current_test_mse > min(test_mse_ot):
      loss_nondecrease_count += 1
  else:
      loss_nondecrease_count = 0

  if loss_nondecrease_count > loss_nondecrease_threshold :
        session.run(inc_gstep)
        loss_nondecrease_count = 0
        print('\tDecreasing learning rate by 0.5')

  test_mse_ot.append(current_test_mse)
  #print('\tTest MSE: %.5f'%np.mean(mse_test_loss_seq))
  print('\tTest MSE: %.5f' % current_test_mse)
  predictions_over_time.append(predictions_seq)
  print('\tFinished Predictions')
  epochs_evolution.append(ep+1)

Может ли это быть нормальным?мне просто увеличить размер тестового набора?Что-то сделано не так?какие-нибудь идеи, пожалуйста, о том, как это проверить / исследовать?

1 Ответ

0 голосов
/ 03 марта 2019

Причиной вышеупомянутой разницы в MSE между обучением и тестированием является то, что мы не вычисляем одно и то же.Во время обучения MSE является средним значением суммы ошибок по временным шагам для каждой выборки в данных обучения, и поэтому оно большое.Во время теста мы делаем N = 50 прогнозов и вычисляем среднюю ошибку между прогнозами и фактическими значениями.Это среднее всегда очень мало, и на приведенном выше графике оно выглядит почти постоянным.

...