LSTM(RNN)ニューラルネットワークを作成し、データストック予測のための教師あり学習を行いました。問題は、それが独自のトレーニングデータで間違っていると予測する理由です。 (注:再現可能な例以下)
次の5日間の株価を予測する簡単なモデルを作成しました。
model = Sequential()
model.add(LSTM(32, activation='sigmoid', input_shape=(x_train.shape[1], x_train.shape[2])))
model.add(Dense(y_train.shape[1]))
model.compile(optimizer='adam', loss='mse')
es = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)
model.fit(x_train, y_train, batch_size=64, epochs=25, validation_data=(x_test, y_test), callbacks=[es])
正しい結果はy_test
(5つの値)にあるため、モデルをトレーニングして、前の90日間を振り返り、val_loss=0.0030
で最良(patience=3
)の結果から重みを復元します。
Train on 396 samples, validate on 1 samples
Epoch 1/25
396/396 [==============================] - 1s 2ms/step - loss: 0.1322 - val_loss: 0.0299
Epoch 2/25
396/396 [==============================] - 0s 402us/step - loss: 0.0478 - val_loss: 0.0129
Epoch 3/25
396/396 [==============================] - 0s 397us/step - loss: 0.0385 - val_loss: 0.0178
Epoch 4/25
396/396 [==============================] - 0s 399us/step - loss: 0.0398 - val_loss: 0.0078
Epoch 5/25
396/396 [==============================] - 0s 391us/step - loss: 0.0343 - val_loss: 0.0030
Epoch 6/25
396/396 [==============================] - 0s 391us/step - loss: 0.0318 - val_loss: 0.0047
Epoch 7/25
396/396 [==============================] - 0s 389us/step - loss: 0.0308 - val_loss: 0.0043
Epoch 8/25
396/396 [==============================] - 0s 393us/step - loss: 0.0292 - val_loss: 0.0056
予測結果はかなり素晴らしいですね。
これは、アルゴリズムが#5エポックから最良の重みを復元したためです。では、このモデルを.h5
ファイルに保存し、-10日戻し、過去5日間を予測します(最初の例では、モデルを作成し、週末の休日を含めて4月17日から23日に検証します。次に、2日でテストしましょう4月8日)。結果:
まったく間違った方向を示しています。これは、モデルがトレーニングされ、4月17日から23日までの検証セットで#5エポックを最もよく使用したためです。もっとトレーニングして、エポックの選択を試してみると、私が何をしても、過去には、予測が間違っている多くの時間間隔があります。
モデルが独自のトレーニング済みデータで誤った結果を表示するのはなぜですか?私はデータをトレーニングしました。このセットのデータを予測する方法を覚えておく必要がありますが、間違って予測します。私が試したもの:
多分私は何かを逃す?何を改善できますか?
これは非常にシンプルで、再現可能なの例です。 yfinance
は、S&P 500株価データをダウンロードします。
"""python 3.7.7
tensorflow 2.1.0
keras 2.3.1"""
import numpy as np
import pandas as pd
from keras.callbacks import EarlyStopping, Callback
from keras.models import Model, Sequential, load_model
from keras.layers import Dense, Dropout, LSTM, BatchNormalization
from sklearn.preprocessing import MinMaxScaler
import plotly.graph_objects as go
import yfinance as yf
np.random.seed(4)
num_prediction = 5
look_back = 90
new_s_h5 = True # change it to False when you created model and want test on other past dates
df = yf.download(tickers="^GSPC", start='2018-05-06', end='2020-04-24', interval="1d")
data = df.filter(['Close', 'High', 'Low', 'Volume'])
# drop last N days to validate saved model on past
df.drop(df.tail(0).index, inplace=True)
print(df)
class EarlyStoppingCust(Callback):
def __init__(self, patience=0, verbose=0, validation_sets=None, restore_best_weights=False):
super(EarlyStoppingCust, self).__init__()
self.patience = patience
self.verbose = verbose
self.wait = 0
self.stopped_Epoch = 0
self.restore_best_weights = restore_best_weights
self.best_weights = None
self.validation_sets = validation_sets
def on_train_begin(self, logs=None):
self.wait = 0
self.stopped_Epoch = 0
self.best_avg_loss = (np.Inf, 0)
def on_Epoch_end(self, Epoch, logs=None):
loss_ = 0
for i, validation_set in enumerate(self.validation_sets):
predicted = self.model.predict(validation_set[0])
loss = self.model.evaluate(validation_set[0], validation_set[1], verbose = 0)
loss_ += loss
if self.verbose > 0:
print('val' + str(i + 1) + '_loss: %.5f' % loss)
avg_loss = loss_ / len(self.validation_sets)
print('avg_loss: %.5f' % avg_loss)
if self.best_avg_loss[0] > avg_loss:
self.best_avg_loss = (avg_loss, Epoch + 1)
self.wait = 0
if self.restore_best_weights:
print('new best Epoch = %d' % (Epoch + 1))
self.best_weights = self.model.get_weights()
else:
self.wait += 1
if self.wait >= self.patience or self.params['epochs'] == Epoch + 1:
self.stopped_Epoch = Epoch
self.model.stop_training = True
if self.restore_best_weights:
if self.verbose > 0:
print('Restoring model weights from the end of the best Epoch')
self.model.set_weights(self.best_weights)
def on_train_end(self, logs=None):
print('best_avg_loss: %.5f (#%d)' % (self.best_avg_loss[0], self.best_avg_loss[1]))
def multivariate_data(dataset, target, start_index, end_index, history_size, target_size, step, single_step=False):
data = []
labels = []
start_index = start_index + history_size
if end_index is None:
end_index = len(dataset) - target_size
for i in range(start_index, end_index):
indices = range(i-history_size, i, step)
data.append(dataset[indices])
if single_step:
labels.append(target[i+target_size])
else:
labels.append(target[i:i+target_size])
return np.array(data), np.array(labels)
def transform_predicted(pr):
pr = pr.reshape(pr.shape[1], -1)
z = np.zeros((pr.shape[0], x_train.shape[2] - 1), dtype=pr.dtype)
pr = np.append(pr, z, axis=1)
pr = scaler.inverse_transform(pr)
pr = pr[:, 0]
return pr
step = 1
# creating datasets with look back
scaler = MinMaxScaler()
df_normalized = scaler.fit_transform(df.values)
dataset = df_normalized[:-num_prediction]
x_train, y_train = multivariate_data(dataset, dataset[:, 0], 0,len(dataset) - num_prediction + 1, look_back, num_prediction, step)
indices = range(len(dataset)-look_back, len(dataset), step)
x_test = np.array(dataset[indices])
x_test = np.expand_dims(x_test, axis=0)
y_test = np.expand_dims(df_normalized[-num_prediction:, 0], axis=0)
# creating past datasets to validate with EarlyStoppingCust
number_validates = 50
step_past = 5
validation_sets = [(x_test, y_test)]
for i in range(1, number_validates * step_past + 1, step_past):
indices = range(len(dataset)-look_back-i, len(dataset)-i, step)
x_t = np.array(dataset[indices])
x_t = np.expand_dims(x_t, axis=0)
y_t = np.expand_dims(df_normalized[-num_prediction-i:len(df_normalized)-i, 0], axis=0)
validation_sets.append((x_t, y_t))
if new_s_h5:
model = Sequential()
model.add(LSTM(32, return_sequences=False, activation = 'sigmoid', input_shape=(x_train.shape[1], x_train.shape[2])))
# model.add(Dropout(0.2))
# model.add(BatchNormalization())
# model.add(LSTM(units = 16))
model.add(Dense(y_train.shape[1]))
model.compile(optimizer = 'adam', loss = 'mse')
# EarlyStoppingCust is custom callback to validate each validation_sets and get average
# it takes Epoch with best "best_avg" value
# es = EarlyStoppingCust(patience = 3, restore_best_weights = True, validation_sets = validation_sets, verbose = 1)
# or there is keras extension with built-in EarlyStopping, but it validates only 1 set that you pass through fit()
es = EarlyStopping(monitor = 'val_loss', patience = 3, restore_best_weights = True)
model.fit(x_train, y_train, batch_size = 64, epochs = 25, shuffle = True, validation_data = (x_test, y_test), callbacks = [es])
model.save('s.h5')
else:
model = load_model('s.h5')
predicted = model.predict(x_test)
predicted = transform_predicted(predicted)
print('predicted', predicted)
print('real', df.iloc[-num_prediction:, 0].values)
print('val_loss: %.5f' % (model.evaluate(x_test, y_test, verbose=0)))
fig = go.Figure()
fig.add_trace(go.Scatter(
x = df.index[-60:],
y = df.iloc[-60:,0],
mode='lines+markers',
name='real',
line=dict(color='#ff9800', width=1)
))
fig.add_trace(go.Scatter(
x = df.index[-num_prediction:],
y = predicted,
mode='lines+markers',
name='predict',
line=dict(color='#2196f3', width=1)
))
fig.update_layout(template='plotly_dark', hovermode='x', spikedistance=-1, hoverlabel=dict(font_size=16))
fig.update_xaxes(showspikes=True)
fig.update_yaxes(showspikes=True)
fig.show()
モデルアーキテクチャとオプティマイザをAdagradに変更した後、結果をある程度改善することができました。
Adagradオプティマイザーを使用する理由は次のとおりです:
学習率をパラメーターに適合させ、頻繁に発生する機能に関連付けられているパラメーターには小さな更新(つまり、低い学習率)を実行し、頻度の低い機能に関連付けられているパラメーターには大きな更新(つまり、高い学習率)を実行します。このため、スパースデータの処理に適しています。
以下のコードを参照してください:
model = Sequential()
model.add(LSTM(units=100,return_sequences=True, kernel_initializer='random_uniform', input_shape=(x_train.shape[1], x_train.shape[2])))
model.add(Dropout(0.2))
model.add(LSTM(units=100,return_sequences=True, kernel_initializer='random_uniform'))
model.add(LSTM(units=100,return_sequences=True, kernel_initializer='random_uniform'))
model.add(Dropout(0.20))
model.add(Dense(units=25, activation='relu'))
model.add(Dense(y_train.shape[1]))
# compile model
model.compile(loss="mse", optimizer='adagrad', metrics=['accuracy'])
model.summary()
在庫予測は非常に困難なタスクであるため、単一のモデルの予測に固執するのではなく、複数のモデルを連携させて予測を作成し、最大投票結果に基づいて、アンサンブル学習アプローチと同様に呼び出しを行うことができます。また、次のようにいくつかのモデルを積み重ねることができます。
ディープフィードフォワードオートエンコーダニューラルネットワークで次元を削減+ディープリカレントニューラルネットワーク+ ARIMA +エクストリームブースティンググラディエントリグレッサー
Adaboost + Bagging + Extra Trees + Gradient Boosting + Random Forest + XGB
強化学習エージェントは、在庫予測で次のように非常に優れています。
非常に機知に富んだリンク here を見つけてください。
モデルが独自のトレーニング済みデータで誤った結果を表示するのはなぜですか?私はデータをトレーニングしました。このセットのデータを予測する方法を覚えておく必要がありますが、間違って予測します。
記憶ではなく、モデルが入力と出力の関係を学習するようにします。モデルが各入力の正しい出力を記憶している場合、トレーニングデータの適合が過剰であると言えます。多くの場合、データの小さなサブセットを使用してモデルをオーバーフィットさせることができます。そのため、それが見たい動作であれば、それを試すことができます。
短い答え:
セットする:
batch_size = 1
epochs = 200
shuffle = False
直観:トレーニングデータの高精度の優先度について説明しています。これは過剰適合を説明しています。そのためには、バッチサイズを1に設定し、エポックを高くして、シャッフルをオフにします。
基本的に、トレーニングデータの結果を改善したい場合は、トレーニングの精度をできるだけ高くする必要があります。あなたはあなたが持っているデータに関してより良いモデルを使うべきです。基本的に、テストの精度に関係なく、この目的のためのトレーニングの精度を確認する必要があります。これはオーバーフィッティングとも呼ばれ、テストデータよりもトレーニングデータの精度が向上します。
このシナリオでは、トレーニングの精度ではなく、テスト/検証の最高の精度が採用されるため、早期停止が影響する場合があります。
それは不十分であり、私があなたがあなたの隠された層にニューロンを追加する必要があることを改善するためです。もう一つのポイントは、アクティベーション機能「relu」を試してみることです。シグモイドは良い結果を与えません。また、出力層で「softmax」を定義する必要があります。