Veri stoğu tahmini için denetimli öğrenmeye sahip bir LSTM (RNN) sinir ağı oluşturdum. Sorun neden kendi eğitim verilerinde yanlış tahmin edilmesidir? (not: aşağıdaki tekrarlanabilir örnek )

Önümüzdeki 5 gün hisse senedi fiyatını tahmin etmek için basit bir model oluşturdum:

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])

Doğru sonuçlar y_test(5 değer) şeklindedir, bu nedenle model trenlerini, önceki 90 gün geriye bakar ve ardından ağırlıkları en iyi ( val_loss=0.0030) sonuçtan geri yükler 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

Tahmin sonucu gayet harika, değil mi?

Çünkü algoritma # 5 dönemindeki en iyi ağırlıkları geri yükledi. Tamam, şimdi bu modeli .h5dosyaya kaydedelim, -10 gün geriye gidelim ve son 5 günü tahmin edelim (ilk örnekte model yaptık ve hafta sonları da dahil olmak üzere 17-23 Nisan'da onayladık, şimdi 2-8 Nisan'da test edelim). Sonuç:

Kesinlikle yanlış yön gösteriyor. Gördüğümüz gibi, model eğitildi ve 17-23 Nisan'da onaylama için en iyi 5. dönemi aldı, ancak 2-8'de değil. Daha fazla antrenman yapmayı seçersem, hangi çağı seçeceğimi seçersem, ne yaparsam yapayım, geçmişte her zaman yanlış tahminleri olan çok fazla zaman aralığı vardır.

Model neden kendi eğitimli verilerinde yanlış sonuçlar gösteriyor? Verileri eğittim, bu setteki verilerin nasıl tahmin edileceğini hatırlamalıyım, ancak yanlış tahmin ediyor. Ayrıca ne denedim:

• Daha fazla veya daha az özellik ekleyerek, 50k + satırlı, 20 yıllık hisse senedi fiyatlarına sahip büyük veri kümeleri kullanın
• Daha gizli katmanlar ekleme, farklı batch_sizes, farklı katman aktivasyonları, bırakmalar, toplu normalleştirme gibi farklı model türleri oluşturun
• Özel EarlyStopping geri arama oluşturun, birçok doğrulama veri kümesinden ortalama val_loss alın ve en iyisini seçin

Belki bir şey özledim? Neyi geliştirebilirim?

İşte çok basit ve tekrarlanabilir bir örnek. yfinanceS&P 500 hisse senedi verilerini indirir.

"""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 ilginç bir bulgu öneriyor. Orijinal soruyu aşağıdaki gibi basitleştireyim.

Model belirli bir zaman serisinde eğitildiyse, model neden önceden eğitilmiş olduğu önceki zaman serileri verilerini yeniden oluşturamıyor?

Bu sorunun cevabı, eğitim sürecinin kendisine gömülü. Yana EarlyStoppingoverfitting önlemek için burada kullanılan, en iyi model olarak kaydedilir epoch=5nerede val_loss=0.0030edilen OP bahsettiği. Bu durumda, eğitim kaybı, 0.0343eğitimin RMSE'sine eşittir 0.185. Veri kümesi kullanılarak ölçeklendiğinden MinMaxScalar, neler olduğunu anlamak için RMSE ölçeklendirmesini geri almamız gerekir.

Zaman dizisinin minimum ve maksimum değerler olduğu tespit edilmiştir 2290ve 3380. Bu nedenle, 0.185eğitimin RMSE'sine sahip olmak, eğitim seti için bile, öngörülen değerlerin, zemin gerçeği değerlerinden yaklaşık olarak 0.185*(3380-2290), yani ~200ortalama birimlerden farklı olabileceği anlamına gelir .

Bu, bir önceki zaman adımında egzersiz verilerinin kendisini tahmin ederken neden büyük bir fark olduğunu açıklar.

Egzersiz verilerini mükemmel bir şekilde taklit etmek için ne yapmalıyım?

Bu soruyu kendimden sordum. Basit cevap, eğitim kaybının yaklaşmasını sağlamak 0, yani modelin gereğinden fazla olması.

Biraz antrenmandan sonra, sadece 1 LSTM tabakası olan ve 32hücreleri olan bir modelin eğitim verilerini yeniden oluşturacak kadar karmaşık olmadığını fark ettim . Bu nedenle, aşağıdaki gibi başka bir LSTM katmanı ekledim.

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')

Ve model, 1000düşünmeden dönemler için eğitildi EarlyStopping.

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

Bu 1000sürecin sonunda, 0.00047sizin durumunuzdaki eğitim kaybından çok daha düşük bir eğitim kaybımız olur. Bu nedenle, modelin eğitim verilerini daha iyi yapılandırmasını bekleriz. 2-8 Nisan için tahmin grafiği aşağıdadır.

Son Not:

Belirli bir veritabanı üzerinde eğitim yapmak, modelin eğitim verilerini mükemmel şekilde yeniden oluşturabileceği anlamına gelmez. Özellikle, aşırı takılmayı önlemek için erken durma, düzenlileştirme ve bırakma gibi yöntemler sunulduğunda, model eğitim verilerini ezberlemek yerine daha genelleştirilebilir olma eğilimindedir.

Model neden kendi eğitimli verilerinde yanlış sonuçlar gösteriyor? Verileri eğittim, bu setteki verilerin nasıl tahmin edileceğini hatırlamalıyım, ancak yanlış tahmin ediyor.

Modelin ezberlemek yerine girdi ve çıktı arasındaki ilişkiyi öğrenmesini istiyorsunuz. Eğer bir model her bir girdi için doğru çıktıyı ezberliyorsa, bunun egzersiz verisine aşırı uyduğunu söyleyebiliriz. Genellikle, verilerin küçük bir alt kümesini kullanarak modeli tersine çevirmeye zorlayabilirsiniz, bu nedenle görmek istediğiniz davranış bu ise bunu deneyebilirsiniz.

Temel olarak Egzersiz verileri için daha iyi sonuç almak istiyorsanız, egzersiz doğruluğunuz mümkün olduğunca yüksek olmalıdır. Sahip olduğunuz veriler için daha iyi bir model kullanmalısınız. Temel olarak, test doğruluğundan bağımsız olarak bu amaç için egzersiz doğruluğunuzun olup olmadığını kontrol etmelisiniz. Buna, test verisinden çok egzersiz verilerinde daha iyi doğruluk sağlayan aşırı sığdırma denir.

Antrenman doğruluğundan ziyade en iyi test / validasyon doğruluğunun alındığı bu senaryoda erken durma etkilenebilir.

Kısa cevap:

Ayarlamak:

batch_size = 1
epochs = 200
shuffle = False

Sezgi: Egzersiz verilerinde yüksek doğruluk önceliğini açıklıyorsunuz. Bu aşırı uydurmayı tarif ediyor. Bunu yapmak için, toplu iş boyutunu 1, çağlar yüksek ve karıştırma kapalı olarak ayarlayın.

Diğerlerinin zaten söylediği gibi, bundan çok şey beklememelisiniz.

Yine de, kodunuzda aşağıdakileri buldum:

1. Sen edilmektedir yeniden uydurma Ölçekleyici eğitim sırasında her zaman ve test. Sınayıcıyı kaydetmeniz ve yalnızca test sırasında verileri dönüştürmeniz gerekir, aksi takdirde sonuçlar biraz farklı olacaktır:

   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. Ayarlayın shuffle=False. Veri kümenizin sırasını korumanız gerekir.

3. Ayarlayın batch_size=1. Daha az sığmaya eğilimli olacağı ve öğrenmenin daha gürültülü olacağı ve hatanın daha az ortalaması alınacağı için.

4. Set epochs=50veya daha fazlası.

Yukarıda belirtilen ayarlarla model elde edildi loss: 0.0037 - val_loss: 3.7329e-04.

Aşağıdaki tahmin örneklerini kontrol edin:

17/04/2020 -> 23/04/2020 tarihinden itibaren:

02/04/2020 -> 08/04/2020 tarihinden itibaren:

25/03/2020 -> 31/03/2020 tarihinden itibaren:

Model neden kendi eğitimli verilerinde yanlış sonuçlar gösteriyor? Verileri eğittim, bu setteki verilerin nasıl tahmin edileceğini hatırlamalıyım, ancak yanlış tahmin ediyor.

Bak ne yapıyorsun:

1. Bazı katmanlarla model oluşturma
2. Training_data ile egzersiz modeli
3. Modeli eğittiğinizde, tüm eğitilebilir parametreler eğitilir (yani, model ağırlıkları kaydedilmiştir)
4. Bu ağırlıklar artık girdi ve çıktı arasındaki ilişkiyi göstermektedir.
5. Aynı training_data'yı tekrar tahmin ettiğinizde, bu sefer eğitimli model çıktı almak için ağırlıkları kullanır.
6. Modelinizin kalitesi artık tahminlere karar veriyor ve veriler aynı olsa bile orijinal sonuçlardan farklı.

Bu eksik ve geliştirmek için gizli katmanlarınıza nöron eklemeniz gereken bir şey. !! Başka bir nokta da 'relu' aktivasyon fonksiyonunu deneyin. Sigmoid iyi sonuç vermez. Ayrıca çıktı katmanınızda 'softmax' tanımlamanız gerekir.

Model mimarisini ve optimize ediciyi Adagrad olarak değiştirdikten sonra sonuçları bir ölçüde geliştirebildim.

Adagrad optimizer'ı kullanmanızın nedeni burada:

Öğrenme hızını parametrelere uyarlar, sık görülen özelliklerle ilişkili parametreler için daha küçük güncellemeler (yani düşük öğrenme hızları) ve sık olmayan özelliklerle ilişkili parametreler için daha büyük güncellemeler (yani yüksek öğrenme hızları) gerçekleştirir. Bu nedenle, seyrek verilerle uğraşmak için çok uygundur.

Lütfen aşağıdaki koda bakın:

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()

Hisse senedi tahmini çok zor bir iştir, bu nedenle tek bir modelin öngörüsüne bağlı kalmak yerine, bir tahmin yapmak için birlikte çalışan birkaç modelimiz olabilir ve daha sonra, oylanan maksimum sonuca dayanarak bir topluluk öğrenme yaklaşımına benzer şekilde çağrı yapabiliriz. Ayrıca, birkaç modeli bir araya getirebiliriz:

1. Boyutu azaltmak için Derin Besleme İleri Otomatik Kodlayıcı Sinir Ağı + Derin Tekrarlayan Sinir Ağı + ARIMA + Aşırı Arttırıcı Gradyan Regresörü

2. Adaboost + Torbalama + Ekstra Ağaçlar + Gradyan Arttırma + Rastgele Orman + XGB

Takviye öğrenme ajanları Stok Tahmininde aşağıdaki gibi oldukça iyi performans gösteriyor:

1. Kaplumbağa ticareti acentesi
2. Hareketli ortalama ajan
3. Sinyal haddeleme maddesi
4. İlke-gradyan aracısı
5. Q-öğrenme ajanı
6. Evrim-strateji ajanı

Lütfen burada çok becerikli bir bağlantı bulun .

Şüpheli # 1 - Düzenleme

Sinir ağları, eğitim verilerinin üzerine sığdırma konusunda harikadır, aslında CIFAR10 (görüntü sınıflandırma görevi) etiketlerini (y değerleri) eğitim veri kümesindeki rastgele etiketlerle değiştiren bir deney vardır ve ağ rastgele etiketlere sığar ve neredeyse sıfır kayıpla sonuçlanır.

sol tarafta yeterince dönem verildiğinde rastgele etiketlerin 0 kayıp civarında olduğunu görebiliriz - mükemmel puan ( derin öğrenmeyi anlamaktan zhang et al 2016 tarafından yeniden düşünmeyi gerektirir )

Öyleyse neden sürekli olmuyor? düzenleme .

Düzenleme (kabaca) model için tanımladığımız optimizasyon probleminden (kayıp) daha zor bir sorunu çözmeye çalışıyor.

sinir ağlarında bazı yaygın düzenlenme yöntemleri:

• erken durma
• bırakmak
• parti normalizasyonu
• ağırlık azalması (örneğin, l1 l2 normları)
• veri büyütme
• rastgele / gauss gürültüsü ekleme

bu yöntemler aşırı takmayı azaltmaya yardımcı olur ve genellikle daha iyi doğrulama ve test performansı sağlar, ancak daha düşük tren performansıyla sonuçlanır (bu son paragrafta açıklandığı gibi önemli değildir).

Tren veri performansı genellikle çok önemli değildir ve bunun için doğrulama setini kullanıyoruz.

Şüpheli # 2 - Model Boyutu

32 adet tekli LSTM katmanı kullanıyorsunuz. bu oldukça küçük. boyutu artırmak deneyin ve hatta iki LSTM katmanı (veya çift yönlü bir) koymak ve eminim model ve optimizer izin verdiğiniz sürece verilerinizi geçersiz kılacak - yani erken durdurma, restore_ağırlık_ağırlıkları ve yukarıda belirtilen herhangi bir diğer düzenlileştirme kaldırmak.

Problem Karmaşıklığı Hakkında Not

sadece geçmişe bakarak gelecekteki hisse senedi fiyatlarını tahmin etmeye çalışmak kolay bir iş değildir ve model eğitim setine mükemmel bir şekilde uysa bile, muhtemelen test setinde veya gerçek dünyada yararlı bir şey yapmayacaktır.

ML kara büyü değil, x örneklerinin y etiketleriyle bir şekilde ilişkilendirilmesi gerekiyor, genellikle (x, y) 'nin bazı dağıtımlardan birlikte alındığını varsayıyoruz.

Bir görüntüyü köpek / kedi sınıfı için manuel olarak etiketlemeniz gerektiğinde bunu düşünmenin daha sezgisel bir yolu - oldukça basit. ancak yalnızca hisse senedinin geçmişine bakarak hisse senedi fiyatını manuel olarak "etiketleyebilir" misiniz?

Bu sorunun ne kadar zor olduğu hakkında bazı sezgi.

Aşırı Donatmaya İlişkin Not

Yüksek antrenman performansını takip etmemeliyiz, antrenman verilerine uydurmayı denemek neredeyse işe yaramaz, çünkü genellikle tren verilerine benzer özelliklere sahip görünmeyen yeni veriler üzerinde bir modelle iyi performans göstermeye çalışırız. tüm fikir verinin özelliklerini genelleştirmeye ve öğrenmeye çalışmak ve hedefle korelasyon, öğrenmenin ne olduğu :)