ทำไมเครือข่ายประสาทคาดการณ์ผิดกับข้อมูลการฝึกอบรมของตัวเอง?


15

ฉันสร้างเครือข่ายประสาท 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 วันล่าสุด (ในตัวอย่างแรกที่เราสร้างแบบจำลองและตรวจสอบในวันที่ 17-23 เมษายนรวมถึงวันหยุดสุดสัปดาห์วันนี้ลองทดสอบวันที่ 2-8 เมษายน) ผลลัพธ์:

ป้อนคำอธิบายรูปภาพที่นี่

มันแสดงให้เห็นถึงทิศทางที่ผิดอย่างแน่นอน อย่างที่เราเห็นนั่นเป็นเพราะแบบจำลองได้รับการฝึกฝนและได้รับการจัดอันดับให้ดีที่สุดสำหรับการตรวจสอบในวันที่ 17-23 เมษายน แต่ไม่ใช่ในวันที่ 2-8 ถ้าฉันลองฝึกให้มากขึ้นเล่นกับสิ่งที่ยุคให้เลือกไม่ว่าฉันจะทำอะไรจะมีช่วงเวลามากมายในอดีตที่มีการทำนายผิด

ทำไมแบบจำลองแสดงผลลัพธ์ที่ไม่ถูกต้องกับข้อมูลที่ผ่านการฝึกอบรมของตัวเอง ฉันฝึกข้อมูลแล้วมันต้องจำไว้ว่าจะทำนายข้อมูลในชุดนี้ได้อย่างไร แต่ทำนายผิด สิ่งที่ฉันพยายาม:

  • ใช้ชุดข้อมูลขนาดใหญ่พร้อมแถว 50k + ราคาหุ้น 20 ปีเพิ่มคุณสมบัติมากขึ้นหรือน้อยลง
  • สร้างรูปแบบที่แตกต่างกันเช่นเพิ่มเลเยอร์ที่ซ่อนอยู่มากขึ้น, batch_size ที่แตกต่างกัน, การเปิดใช้งานเลเยอร์ที่แตกต่างกัน, การดรอป, การแบทช์การทำให้ปกติ
  • สร้างการเรียกกลับก่อนกำหนดที่กำหนดเองรับค่า val_loss โดยเฉลี่ยจากชุดข้อมูลการตรวจสอบความถูกต้องจำนวนมากและเลือกที่ดีที่สุด

บางทีฉันอาจจะพลาดบางสิ่งบางอย่าง? ฉันจะปรับปรุงอะไรดี

นี่เป็นตัวอย่างที่ง่ายและทำซ้ำได้ 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()

3
ตัวอย่างที่ทำซ้ำได้ยากมากในปัจจุบัน (ตรงกันข้ามกับ gazzilions ของคำถามที่คล้ายกันโดยไม่มี) ซึ่งเป็นความคิดที่ดีที่จะโฆษณาการมีอยู่ของมันในตอนต้นโพสต์ของคุณ (เพิ่มเติม);
desertnaut

7
ปัญหาอาจเกิดจากการที่คุณคาดหวังการคาดการณ์ที่มากเกินไปจากตลาดหุ้น หากคุณฝึกฝนแบบจำลองตามลำดับที่มีการโยนเหรียญ 1 ล้านเหรียญและลองใช้เพื่อคาดการณ์การโยนเหรียญมันจะไม่น่าแปลกใจเลยที่แบบจำลองจะเข้าใจผิดแม้ว่าการโยนมาจากข้อมูลการฝึกอบรม - แบบจำลอง ไม่คาดว่าจะจดจำข้อมูลการฝึกอบรมและทำการไหลกลับ
user2357112 รองรับ Monica

2
นอกเหนือจากสิ่งที่ @ user2357112supportsMonica กล่าวว่าแบบจำลองของคุณมีค่าเฉลี่ยซึ่งเป็นสิ่งที่ฉันคาดหวังว่าแบบจำลองนี้จะได้รับจริง ๆ (อย่างน้อยก็มีความสอดคล้องกัน) และคุณคาดหวังมากเกินไปจาก 5 วัน ข้อมูล. คุณต้องการข้อมูลมากขึ้นเพื่อให้สามารถพูดได้อย่างมีนัยสำคัญว่าข้อผิดพลาดในแบบจำลองของคุณคืออะไร
แอรอน

มีพารามิเตอร์มากขึ้นในการปรับรุ่น ฉันลองคู่ของพวกเขาเช่นการหยุดก่อนกำหนด (ความอดทน = 20) จำนวน epoch ที่เพิ่มขึ้นเพิ่มหน่วย lstm จาก 32 เป็น 64 เป็นต้นผลลัพธ์ผลลัพธ์ดีขึ้นมาก ตรวจสอบที่นี่github.com/jvishnuvardhan/Stackoverflow_Questions/blob/master/... ดังที่ @sirjay เพิ่มคุณสมบัติเพิ่มเติม (ปัจจุบันมีเพียง 4) เพิ่มเลเยอร์เพิ่มเติม (lstm, batchnorm, dropout และอื่น ๆ ) การใช้การปรับให้เหมาะสมของพารามิเตอร์แบบไฮเปอร์จะส่งผลให้ประสิทธิภาพดีขึ้นมาก
Vishnuvardhan Janapati

@VishnuvardhanJanapati ขอบคุณสำหรับการตรวจสอบ ฉันรวบรวมรหัสรุ่นที่บันทึกไว้ของคุณจากนั้นตั้งค่าdf.drop(df.tail(10).index, inplace=True)มันแสดงผลลัพธ์ที่ไม่ดีเหมือนที่ฉันมี
sirjay

คำตอบ:


4

OP สมมุติฐานการค้นพบที่น่าสนใจ ให้ฉันลดความซับซ้อนของคำถามเดิมดังนี้

หากแบบจำลองนั้นได้รับการฝึกอบรมในช่วงเวลาที่เฉพาะเจาะจงทำไมแบบจำลองไม่สามารถสร้างข้อมูลชุดเวลาก่อนหน้าซึ่งไม่ได้รับการฝึกฝนแล้ว

คำตอบก็คือความก้าวหน้าในการฝึกฝน เนื่องจากEarlyStoppingถูกใช้ที่นี่เพื่อหลีกเลี่ยงการ overfitting โมเดลที่ดีที่สุดจะถูกบันทึกไว้ที่epoch=5ซึ่งval_loss=0.0030OP กล่าวถึง ในกรณีนี้การสูญเสียการฝึกอบรมคือการที่เท่าเทียมกัน0.0343, ที่อยู่, RMSE 0.185ของการฝึกอบรมคือ เนื่องจากชุดข้อมูลถูกปรับขนาดโดยใช้MinMaxScalarเราจำเป็นต้องยกเลิกการปรับขนาดของ RMSE เพื่อทำความเข้าใจว่าเกิดอะไรขึ้น

ต่ำสุดและสูงสุดค่าของลำดับเวลาที่จะพบว่ามีและ2290 3380ดังนั้น0.185ในฐานะที่เป็น RMSE ของการฝึกอบรมหมายความว่าแม้ในชุดฝึกอบรมค่าที่คาดการณ์อาจแตกต่างจากค่าความจริงพื้นฐานโดยประมาณ0.185*(3380-2290)นั่นคือ~200หน่วยโดยเฉลี่ย

สิ่งนี้อธิบายได้ว่าทำไมจึงมีความแตกต่างใหญ่เมื่อทำนายข้อมูลการฝึกอบรมในขั้นตอนก่อนหน้า

ฉันควรทำอย่างไรเพื่อเลียนแบบข้อมูลการฝึกอบรมอย่างสมบูรณ์

ฉันถามคำถามนี้จากตัวเอง คำตอบง่ายๆคือทำให้การสูญเสียการฝึกอบรมใกล้เข้า0กับแบบจำลองมากเกินไป

หลังจากการฝึกอบรมฉันรู้ว่าแบบจำลองที่มีเลเยอร์ LSTM เพียง 1 ชั้นที่มี32เซลล์ไม่ซับซ้อนพอที่จะสร้างข้อมูลการฝึกอบรมขึ้นมาใหม่ ดังนั้นฉันได้เพิ่มเลเยอร์ 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')

และรูปแบบการฝึกอบรมสำหรับ1000epochs EarlyStoppingโดยไม่พิจารณา

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

ในตอนท้ายของ1000ยุคที่เรามีการสูญเสียการฝึกอบรม0.00047ซึ่งต่ำกว่าการสูญเสียการฝึกอบรมในกรณีของคุณ ดังนั้นเราคาดว่ารูปแบบการสร้างข้อมูลการฝึกอบรมจะดีขึ้น ต่อไปนี้เป็นพล็อตการทำนายสำหรับวันที่ 2-8 เม.ย.

คาดการณ์

หมายเหตุสุดท้าย:

การฝึกอบรมในฐานข้อมูลที่เฉพาะเจาะจงไม่ได้หมายความว่าแบบจำลองควรจะสามารถสร้างข้อมูลการฝึกอบรมได้อย่างสมบูรณ์แบบ โดยเฉพาะอย่างยิ่งเมื่อมีการแนะนำวิธีต่าง ๆ เช่นการหยุดก่อนกำหนดการทำให้เป็นปกติและการออกกลางคันเพื่อหลีกเลี่ยงการ overfitting ตัวแบบมีแนวโน้มที่จะเป็น generalizable มากกว่าการจดจำข้อมูลการฝึกอบรม


2

ทำไมแบบจำลองแสดงผลลัพธ์ที่ไม่ถูกต้องกับข้อมูลที่ผ่านการฝึกอบรมของตัวเอง ฉันฝึกข้อมูลแล้วมันต้องจำไว้ว่าจะทำนายข้อมูลในชุดนี้ได้อย่างไร แต่ทำนายผิด

คุณต้องการให้โมเดลเรียนรู้ความสัมพันธ์ระหว่างอินพุตและเอาต์พุตแทนการท่องจำ หากแบบจำลองจดจำเอาต์พุตที่ถูกต้องสำหรับแต่ละอินพุตเราสามารถพูดได้ว่ามันเหมาะสมกับข้อมูลการฝึกอบรมมากเกินไป บ่อยครั้งที่คุณสามารถบังคับให้แบบจำลองมีความเหมาะสมมากเกินไปโดยใช้ชุดย่อยของข้อมูลเล็ก ๆ น้อย ๆ ดังนั้นหากนั่นเป็นพฤติกรรมที่คุณต้องการเห็นคุณสามารถลองทำสิ่งนั้นได้


1

โดยทั่วไปหากคุณต้องการผลลัพธ์ที่ดีกว่าสำหรับข้อมูลการฝึกอบรมความแม่นยำในการฝึกอบรมของคุณควรสูงที่สุดเท่าที่จะเป็นไปได้ คุณควรใช้แบบจำลองที่ดีกว่าสำหรับข้อมูลที่คุณมี โดยทั่วไปคุณควรตรวจสอบว่าความถูกต้องในการฝึกอบรมของคุณเพื่อจุดประสงค์นี้โดยไม่คำนึงถึงความแม่นยำในการทดสอบ สิ่งนี้เรียกว่าการ overfitting ซึ่งให้ความแม่นยำในการฝึกอบรมมากกว่าข้อมูลการทดสอบ

การหยุดก่อนกำหนดอาจมีผลกับสถานการณ์นี้ซึ่งมีการทดสอบความถูกต้อง / การตรวจสอบความถูกต้องที่ดีที่สุดมากกว่าความแม่นยำในการฝึกอบรม


1

คำตอบสั้น ๆ :

ตั้ง:

batch_size = 1
epochs = 200
shuffle = False

ปรีชา: คุณกำลังอธิบายถึงลำดับความสำคัญของความแม่นยำสูงในข้อมูลการฝึกอบรม นี่คือคำอธิบายที่มากเกินไป ในการทำเช่นนั้นให้ตั้งค่าขนาดแบทช์เป็น 1 ค่าสูงสุดของยุคและสับออก


1

อย่างที่คนอื่นพูดไปแล้วคุณไม่ควรคาดหวังอะไรมากมาย

อย่างไรก็ตามฉันพบสิ่งต่อไปนี้ในรหัสของคุณ:

  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ชุด เพราะมันจะมีแนวโน้มที่จะ overfitting น้อยและการเรียนรู้จะมีเสียงดังมากขึ้นและข้อผิดพลาดน้อยกว่าค่าเฉลี่ย

  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:

ป้อนคำอธิบายรูปภาพที่นี่


0

ทำไมแบบจำลองแสดงผลลัพธ์ที่ไม่ถูกต้องกับข้อมูลที่ผ่านการฝึกอบรมของตัวเอง ฉันฝึกข้อมูลแล้วมันต้องจำไว้ว่าจะทำนายข้อมูลในชุดนี้ได้อย่างไร แต่ทำนายผิด

ดูสิว่าคุณกำลังทำอะไรอยู่:

  1. การสร้างแบบจำลองที่มีเลเยอร์บางอย่าง
  2. รูปแบบการฝึกอบรมด้วย training_data
  3. เมื่อคุณฝึกแบบจำลองพารามิเตอร์ที่ฝึกได้ทั้งหมดจะได้รับการฝึกฝน (เช่นน้ำหนักของแบบจำลองได้รับการบันทึก)
  4. ตุ้มน้ำหนักเหล่านี้แสดงถึงความสัมพันธ์ระหว่างอินพุตและเอาต์พุต
  5. เมื่อคุณคาดการณ์ training_data เดียวกันอีกครั้งคราวนี้รุ่นที่ฝึกอบรมจะใช้น้ำหนักเพื่อให้ได้ผลลัพธ์
  6. คุณภาพของแบบจำลองของคุณจะตัดสินใจการคาดการณ์ดังนั้นจึงแตกต่างจากผลลัพธ์ต้นฉบับแม้ว่าข้อมูลจะเหมือนกัน

0

มันไม่เหมาะสมและปรับปรุงว่าฉันต้องการเพิ่มเซลล์ประสาทเข้าไปในเลเยอร์ที่ซ่อนอยู่ของคุณ !! อีกจุดหนึ่งคือลองเปิดใช้งานฟังก์ชั่น 'relu' Sigmoid ไม่ให้ผลลัพธ์ที่ดี นอกจากนี้คุณต้องกำหนด 'softmax' ในเลเยอร์ผลลัพธ์ของคุณ!


ดูเหมือนคุณเก็บความลับในการทำนายตลาด เขาควรทำอะไรอีก
Daniel Scott

2
softmax สำหรับการจัดหมวดหมู่มันเป็นปัญหาการถดถอย
ShmulikA

0

หลังจากเปลี่ยนสถาปัตยกรรมโมเดลและเครื่องมือเพิ่มประสิทธิภาพเป็น 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. Deep-forward Auto-Encoder Neural Network เพื่อลดขนาด + เครือข่าย Neural Deep Recurrent + ARIMA + Regressor ไล่สีไล่ระดับที่เพิ่มขึ้นอย่างมาก

  2. Adaboost + การบรรจุต้นไม้พิเศษ + + การไล่ระดับสีแบบสุ่ม + ฟอเรสต์แบบสุ่ม + XGB

ตัวแทนการเรียนรู้การเสริมแรงนั้นทำได้ค่อนข้างดีในการทำนายสต็อกเช่น:

  1. ตัวแทนซื้อขายเต่า
  2. ตัวแทนเฉลี่ยเคลื่อนที่
  3. ตัวแทนกลิ้งสัญญาณ
  4. ตัวแทนการไล่ระดับนโยบาย
  5. ตัวแทน Q-learning
  6. ตัวแทนกลยุทธ์วิวัฒนาการ

กรุณาพบลิงค์ไหวพริบมากที่นี่


อาดัมยังมีคุณสมบัติเหล่านี้จริง ๆ แล้วอดัมเป็นวิวัฒนาการของอาดากราด
ShmulikA

0

ผู้ต้องสงสัย # 1 - การทำให้เป็นมาตรฐาน

โครงข่ายใยประสาทเทียมมีข้อมูลการฝึกอบรมมากเกินไปจริง ๆ แล้วมีการทดลองแทนที่ฉลาก CIFAR10 (งานการจำแนกรูปภาพ) (ค่า y) โดยการสุ่มป้ายบนชุดข้อมูลการฝึกอบรมและเครือข่ายเหมาะกับฉลากสุ่มทำให้สูญเสียเกือบเป็นศูนย์

ป้อนคำอธิบายรูปภาพที่นี่

ทางด้านซ้ายเราจะเห็นว่ามีป้ายกำกับแบบสุ่มจำนวนมากพอที่จะได้รับประมาณ 0 การสูญเสีย - คะแนนที่สมบูรณ์แบบ (จากความเข้าใจการเรียนรู้ลึกต้องมีการคิดใหม่โดย zhang et al 2016 )

เหตุใดจึงไม่เกิดขึ้นตลอดเวลา การทำให้เป็นมาตรฐาน

การทำให้เป็นมาตรฐานคือ (โดยประมาณ) พยายามที่จะแก้ปัญหาที่ยากกว่าปัญหาการเพิ่มประสิทธิภาพ (การสูญเสีย) ที่เรากำหนดไว้สำหรับแบบจำลอง

วิธีการทำให้เป็นมาตรฐานทั่วไปบางอย่างในเครือข่ายประสาทเทียม:

  • หยุดก่อน
  • การออกกลางคัน
  • การทำให้เป็นมาตรฐาน
  • น้ำหนักตัวลดลง (เช่น l1 l2 norms)
  • การเพิ่มข้อมูล
  • การเพิ่มเสียงแบบสุ่ม / เกาส์เซียน

วิธีการเหล่านี้ช่วยลดการ overfitting และมักจะส่งผลในการตรวจสอบและทดสอบประสิทธิภาพที่ดีขึ้น แต่ส่งผลให้ประสิทธิภาพรถไฟลดลง (ซึ่งไม่สำคัญจริงตามที่อธิบายไว้ในวรรคสุดท้าย)

ประสิทธิภาพของข้อมูลรถไฟมักจะไม่สำคัญและเราใช้ชุดการตรวจสอบ

ผู้ต้องสงสัย # 2 - ขนาดของโมเดล

คุณกำลังใช้เลเยอร์ LSTM เดี่ยวกับ 32 หน่วย นั่นมันเล็กมาก ลองเพิ่มขนาดและใส่เลเยอร์ LSTM สองชั้น (หรือแบบสองทิศทาง) และฉันแน่ใจว่าแบบจำลองและเครื่องมือเพิ่มประสิทธิภาพจะทำให้ข้อมูลของคุณเกินความเหมาะสมตราบใดที่คุณปล่อยให้พวกเขานั่นคือเอาการหยุดต้นเร็วคืนค่า _last_weights

หมายเหตุเกี่ยวกับความซับซ้อนของปัญหา

การพยายามทำนายราคาหุ้นในอนาคตเพียงแค่ดูที่ประวัติไม่ใช่เรื่องง่ายและแม้ว่าตัวแบบ (สามารถ) พอดีกับชุดฝึกอบรมได้อย่างสมบูรณ์แบบมันอาจจะไม่ทำสิ่งใดที่มีประโยชน์ในชุดทดสอบหรือในโลกแห่งความเป็นจริง

ML ไม่ใช่เวทมนต์สีดำตัวอย่าง x จะต้องมีความสัมพันธ์ในทางใดทางหนึ่งกับแท็ก y เรามักจะคิดว่า (x, y) ถูกดึงจากการแจกแจงบางอย่างด้วยกัน

วิธีคิดที่ใช้งานง่ายขึ้นเมื่อคุณต้องติดแท็กรูปภาพด้วยตนเองสำหรับสุนัข / แมว แต่คุณสามารถ "ติดแท็ก" ราคาหุ้นด้วยตนเองโดยดูที่ประวัติของสต็อกเพียงอย่างเดียวได้หรือไม่

นั่นคือสัญชาตญาณว่าปัญหานี้ยากเพียงใด

หมายเหตุเกี่ยวกับ Overfitting

เราไม่ควรไล่ตามประสิทธิภาพการฝึกอบรมที่สูงกว่ามันเกือบจะไร้ประโยชน์ที่จะลองใช้ข้อมูลการฝึกอบรมให้มากเกินไปเพราะเรามักจะพยายามทำแบบจำลองให้ดีกับข้อมูลที่มองไม่เห็นใหม่ที่มีคุณสมบัติคล้ายกับข้อมูลรถไฟ ความคิดทั้งหมดคือการพยายามที่จะพูดคุยและเรียนรู้คุณสมบัติของข้อมูลและความสัมพันธ์กับเป้าหมายนั่นคือสิ่งที่การเรียนรู้ :)

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.