데이터 스톡 예측을위한지도 학습을 통해 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 일에 모델을 만들고 유효성을 검사 한 후 4 월 2-8 일에 테스트하겠습니다). 결과:

절대적으로 잘못된 방향을 보여줍니다. 보시다시피, 모델이 훈련되었고 4 월 17-23 일에 설정된 유효성 검사에 5 위를 차지했지만 2-8에서는 그렇지 않았습니다. 더 많은 훈련을 시도하고, 내가 선택하는 신기원을 가지고 무엇을하든, 과거에는 항상 잘못된 예측을하는 많은 시간 간격이 있습니다.

훈련 된 데이터에서 모델이 왜 잘못된 결과를 보여줍니까? 나는 데이터를 훈련시켰다. 그것은이 세트의 데이터를 예측하는 방법을 기억해야하지만, 잘못 예측한다. 내가 시도한 것 :

• 50k + 행, 20 년 주가로 대규모 데이터 세트를 사용하여 더 많거나 적은 기능 추가
• 더 많은 숨겨진 레이어 추가, 다른 batch_sizes, 다른 레이어 활성화, 드롭 아웃, 배치 정규화와 같은 다른 유형의 모델 생성
• 사용자 정의 EarlyStopping 콜백을 만들고 많은 유효성 검사 데이터 세트에서 평균 val_loss를 얻고 가장 적합한 것을 선택하십시오.

어쩌면 내가 뭔가를 그리워? 무엇을 개선 할 수 있습니까?

다음은 매우 간단하고 재현 가능한 예입니다. yfinanceS & 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()

OP는 흥미로운 발견을 가정합니다. 다음과 같이 원래 질문을 단순화하겠습니다.

모델이 특정 시계열에 대해 훈련 된 경우 모델이 이미 훈련 된 이전 시계열 데이터를 재구성 할 수없는 이유는 무엇입니까?

답은 훈련 과정 자체에 포함되어 있습니다. 이후 EarlyStoppingoverfitting 방지하기 위해 여기에 사용되는, 최고의 모델이 저장됩니다 epoch=5곳 val_loss=0.0030으로 OP에 의해 언급했다. 이 경우 훈련 손실은 0.0343, 즉 훈련의 RMSE와 같습니다 0.185. 데이터 세트는 다음을 사용하여 조정되므로MinMaxScalar RMSE의 크기 조정을 취소하여 진행 상황을 이해해야합니다.

시간 순서의 최소값과 최대 값은 2290및 3380입니다. 따라서 0.185훈련의 RMSE를 갖는 것은 훈련 세트에 대해서도 예측 된 값이 대략 실제 단위와 평균 0.185*(3380-2290), 즉 ~200단위로 다를 수 있음을 의미합니다 .

이것은 이전 시간 단계에서 훈련 데이터 자체를 예측할 때 큰 차이가있는 이유를 설명합니다.

교육 데이터를 완벽하게 에뮬레이트하려면 어떻게해야합니까?

나는이 질문을 나 자신에게 물었다. 간단한 대답은 훈련 손실이 가까워 0지도록하는 것입니다.

일부 훈련 후, 32셀이있는 1 LSTM 레이어 만있는 모델 이 훈련 데이터를 재구성하기에 충분히 복잡하지 않다는 것을 깨달았습니다 . 따라서 다음과 같이 다른 LSTM 레이어를 추가했습니다.

model = Sequential()
    model.add(LSTM(32, return_sequences=True, activation = 'sigmoid', input_shape=(x_train.shape[1], x_train.shape[2])))
    # model.add(Dropout(0.2))
    # model.add(BatchNormalization())
    model.add(LSTM(units = 64, return_sequences=False,))
    model.add(Dense(y_train.shape[1]))
    model.compile(optimizer = 'adam', loss = 'mse')

그리고이 모델은 1000고려하지 않고 신기원을 위해 훈련되었습니다 EarlyStopping.

model.fit(x_train, y_train, batch_size = 64, epochs = 1000, shuffle = True, validation_data = (x_test, y_test))

1000에포크가 끝나면 0.00047훈련 손실이 귀하의 경우 훈련 손실보다 훨씬 낮습니다. 따라서 모델이 훈련 데이터를 더 잘 재구성 할 것으로 기대합니다. 다음은 4 월 2 일 -8 일에 대한 예측 도표입니다.

마지막 메모 :

특정 데이터베이스에 대한 교육이 모델이 교육 데이터를 완벽하게 재구성 할 수 있어야한다는 의미는 아닙니다. 특히, 조기 정지, 정규화 및 드롭 아웃과 같은 방법이 과적 합을 피하기 위해 도입 될 때 모델은 훈련 데이터를 암기하는 것보다 더 일반화되는 경향이 있습니다.

훈련 된 데이터에서 모델이 왜 잘못된 결과를 보여줍니까? 나는 데이터를 훈련시켰다. 그것은이 세트의 데이터를 예측하는 방법을 기억해야하지만, 잘못 예측한다.

모델이 암기 대신 입력과 출력의 관계를 배우기를 원합니다. 모델이 각 입력에 대한 올바른 출력을 기억하는 경우 훈련 데이터가 적합하지 않다고 말할 수 있습니다. 데이터의 작은 하위 집합을 사용하여 모델이 과적 합되도록 할 수있는 경우가 종종 있으므로 원하는 동작을 시도하면됩니다.

기본적으로 훈련 데이터에 대한 더 나은 결과를 얻으려면 훈련 정확도가 가능한 높아야합니다. 보유한 데이터와 관련하여 더 나은 모델을 사용해야합니다. 기본적으로 테스트 정확도에 관계없이이 목적에 대한 훈련 정확도를 확인해야합니다. 이것을 과적 합이라고도하며, 이는 시험 데이터보다는 훈련 데이터의 정확도를 향상시킵니다.

훈련 정확도보다는 최상의 테스트 / 검증 정확도를 취하는이 시나리오에서는 조기 중지가 영향을받을 수 있습니다.

짧은 대답 :

세트:

batch_size = 1
epochs = 200
shuffle = False

직감 : 훈련 데이터에서 높은 정확도의 우선 순위를 설명하고 있습니다. 이것은 과적 합을 설명합니다. 이렇게하려면 배치 크기를 1, 에포크가 높고 셔플 오프로 설정하십시오.

훈련 된 데이터에서 모델이 왜 잘못된 결과를 보여줍니까? 나는 데이터를 훈련시켰다. 그것은이 세트의 데이터를 예측하는 방법을 기억해야하지만, 잘못 예측한다.

당신이하고있는 것을보십시오 :

1. 일부 레이어로 모델 만들기
2. training_data를 사용한 훈련 모델
3. 모델을 훈련하면 모든 훈련 가능한 매개 변수가 훈련됩니다 (예 : 모델의 무게가 저장 됨)
4. 이 가중치는 이제 입력과 출력 사이의 관계를 나타냅니다.
5. 동일한 training_data를 다시 예측하면이 시간 훈련 된 모델은 가중치를 사용하여 출력을 얻습니다.
6. 이제 모델의 품질에 따라 예측이 결정되므로 데이터가 동일하더라도 원래 결과와 다릅니다.

몸에 잘 맞지 않아서 숨겨진 레이어에 뉴런을 추가해야한다는 점을 개선했습니다. !! 또 다른 요점은 'relu'활성화 기능입니다. S 자형은 좋은 결과를 제공하지 않습니다. 또한 출력 레이어에서 'softmax'를 정의해야합니다.!

모델 아키텍처와 옵티 마이저를 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()

주식 예측은 단일 모델의 예측을 고수하기보다는 매우 까다로운 작업이므로, 여러 모델을 함께 사용하여 예측을 수행 한 다음 앙상블 학습 방식과 유사하게 최대 투표 결과를 기반으로 전화를 걸 수 있습니다. 또한 다음과 같이 몇 가지 모델을 함께 쌓을 수 있습니다.

1. 차원을 줄이기위한 딥 피드 포워드 자동 인코더 신경망 + 딥 재발 신경망 + ARIMA + 극한 증감 그라디언트 회귀

2. Adaboost + Bagging + Extra Trees + Gradient Boosting + Random Forest + XGB

강화 학습 에이전트는 다음과 같이 주식 예측에서 꽤 잘하고 있습니다.

1. 거북이 무역 에이전트
2. 이동 평균 에이전트
3. 신호 롤링 에이전트
4. 정책 그라디언트 에이전트
5. Q- 러닝 에이전트
6. 진화 전략 요원

여기 에서 매우 유용한 링크를 찾으 십시오 .

용의자 # 1-정규화

신경망은 훈련 데이터를 과적 합하는 데 능숙 합니다. 실제로 훈련 데이터 세트에서 CIFAR10 (이미지 분류 작업) 레이블 (y 값)을 임의의 레이블로 대체 하는 실험 이 있으며 네트워크는 임의의 레이블을 맞추므로 손실이 거의 없습니다.

왼쪽에서 우리는 충분한 에포크가 주어지면 임의의 레이블이 약 0의 손실-완벽한 점수 를 얻음을 알 수 있습니다 (딥 학습 을 이해함으로써 zhang et al 2016의 일반화를 다시 생각해야 함 )

왜 항상 일어나지 않습니까? 정규화 .

정규화는 모델에 대해 정의한 최적화 문제 (손실)보다 어려운 문제를 해결하려고합니다.

신경망에서 몇 가지 일반적인 정규화 방법 :

• 조기 정지
• 탈락
• 배치 정규화
• 체중 감량 (예 : l1 l2 규범)
• 데이터 확대
• 랜덤 / 가우시안 노이즈 추가

이러한 방법은 과적 합을 줄이고 일반적으로 검증 및 테스트 성능을 향상 시키지만 트레인 성능을 저하시킵니다 (마지막 단락에서 설명한대로 실제로 중요하지 않음).

열차 데이터 성능은 일반적으로 그다지 중요하지 않으며 검증 세트를 사용합니다.

용의자 # 2-모델 크기

32 단위의 단일 LSTM 레이어를 사용하고 있습니다. 꽤 작습니다. 크기를 늘리고 두 개의 LSTM 레이어 (또는 양방향 레이어)를 넣으십시오. 모델과 옵티마이 저가 데이터를 허용하는 한 데이터를 과적 합할 것이라고 확신합니다. 즉, 조기 중지, restore_last_weights 및 위에서 지정한 다른 정규화를 제거하십시오.

문제 복잡성에 대한 참고 사항

역사를 살펴 보는 것만으로 미래의 주가를 예측하는 것은 쉬운 일이 아니며, 모델이 훈련 세트에 완벽하게 맞을 수 있다고해도 테스트 세트 나 실제 세계에서는 유용한 것이 없을 것입니다.

ML은 흑 마법이 아니며, x 샘플은 어떤 식 으로든 y 태그와 상관 관계가 있어야합니다. 우리는 보통 (x, y)가 어떤 분포에서 함께 나온다고 가정합니다.

개 / 고양이 클래스에 대해 수동으로 이미지에 태그를 추가해야하는 경우보다 직관적으로 생각하면됩니다. 하지만 해당 주식의 이력 만보고 수동으로 주식 가격을 "태그"할 수 있습니까?

이것이이 문제가 얼마나 어려운지에 대한 직관입니다.

과적 합에 대한 참고 사항

우리는 일반적으로 기차 데이터와 비슷한 속성을 가진 보이지 않는 새로운 데이터에 대한 모델로 잘 수행하려고 시도하기 때문에 훈련 데이터를 과적 합하기 위해 거의 쓸모없는 훈련 성능을 추구해서는 안됩니다 . 모든 아이디어는 데이터의 속성과 목표와의 상관 관계를 일반화하고 배우려고 노력하는 것입니다.

다른 사람들이 이미 말했듯이, 당신은 이것으로부터 많은 것을 기 대해서는 안됩니다.

그럼에도 불구하고 코드에서 다음을 발견했습니다.

1. 당신이되어 다시 피팅 스케일러에게 훈련 동안 모든 시간 과 테스트를. 테스트 중에는 sacler를 저장하고 데이터 만 변환해야합니다. 그렇지 않으면 결과가 약간 다릅니다.

   from sklearn.externals import joblib
   scaler_filename = "scaler.save"
   if new_s_h5:
       scaler = MinMaxScaler()
       df_normalized = scaler.fit_transform(df.values)
       joblib.dump(scaler, scaler_filename)
   
   else:
       scaler = joblib.load(scaler_filename)
       df_normalized = scaler.transform(df.values)

2. 설정하십시오 shuffle=False. 데이터 세트의 순서를 유지해야합니다.

3. 설정하십시오 batch_size=1. 과적 합이 적고 학습이 더 시끄럽고 평균 오차가 줄어 듭니다.

4. 세트 epochs=50이상

위에서 언급 한 설정으로 모델이 달성되었습니다. loss: 0.0037 - val_loss: 3.7329e-04 .

다음 예측 샘플을 확인하십시오.

17/04/2020에서-> 23/04/2020 :

02/04/2020에서-> 08/04/2020에서 :

25/03/2020에서-> 31/03/2020 :