Mengapa jaringan saraf memprediksi data pelatihannya sendiri salah?


17

Saya membuat jaringan saraf LSTM (RNN) dengan pembelajaran terawasi untuk prediksi stok data. Masalahnya adalah mengapa ia memprediksi data pelatihannya sendiri salah? (catatan: contoh yang dapat direproduksi di bawah)

Saya membuat model sederhana untuk memprediksi harga saham 5 hari ke depan:

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

Hasil yang benar adalah dalam y_test(5 nilai), jadi model melatih, melihat ke belakang 90 hari sebelumnya dan kemudian mengembalikan bobot dari yang terbaik ( val_loss=0.0030) hasil dengan 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

Hasil prediksi cukup mengagumkan, bukan?

masukkan deskripsi gambar di sini

Itu karena algoritma mengembalikan bobot terbaik dari # 5 jaman. Oke, sekarang mari kita simpan model ini ke .h5file, mundur -10 hari dan prediksi 5 hari terakhir (pada contoh pertama kami membuat model dan memvalidasi pada 17-23 April termasuk hari libur akhir pekan, sekarang mari kita uji pada 2-8 April). Hasil:

masukkan deskripsi gambar di sini

Ini menunjukkan arah yang benar-benar salah. Seperti yang kita lihat itu karena model dilatih dan mengambil # 5 zaman terbaik untuk validasi ditetapkan pada 17-23 April, tetapi tidak pada 2-8. Jika saya mencoba melatih lebih banyak, bermain dengan zaman apa yang harus dipilih, apa pun yang saya lakukan, selalu ada banyak interval waktu di masa lalu yang memiliki prediksi salah.

Mengapa model menunjukkan hasil yang salah pada data terlatihnya sendiri? Saya melatih data, harus ingat bagaimana memprediksi data pada set ini, tetapi memprediksi salah. Apa yang saya coba:

  • Gunakan kumpulan data besar dengan baris 50k +, harga saham 20 tahun, menambah lebih banyak fitur
  • Buat berbagai jenis model, seperti menambahkan lebih banyak lapisan tersembunyi, ukuran batch_size yang berbeda, aktivasi lapisan yang berbeda, dropout, batchnormalisasi
  • Buat callback EarlyStopping kustom, dapatkan val_loss rata-rata dari banyak set data validasi dan pilih yang terbaik

Mungkin saya melewatkan sesuatu? Apa yang bisa saya tingkatkan?

Ini adalah contoh yang sangat sederhana dan dapat direproduksi . yfinancemengunduh data saham 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
Contoh-contoh yang dapat direproduksi sangat langka saat ini (berbeda dengan gazzilions dari pertanyaan serupa tanpa) yang bisa dibilang ide yang baik untuk mengiklankan keberadaannya di awal posting Anda (ditambahkan);)
desertnaut

7
Masalahnya mungkin saja Anda mengharapkan terlalu banyak prediksi keluar dari pasar saham. Jika Anda melatih suatu model pada urutan 1 juta koin terbalik dan kemudian mencoba membuatnya untuk memprediksi koin balik, itu tidak akan mengejutkan bagi model untuk membuat kesalahan, bahkan jika membalik berasal dari data pelatihan - model tidak diharapkan untuk menghafal data pelatihannya dan memuntahkannya.
user2357112 mendukung Monica

2
Selain apa yang dikatakan @ user2357112supportsMonica, model Anda memiliki hak yang benar, yang benar-benar semua yang saya harapkan akan diperoleh model seperti ini (setidaknya dengan konsistensi apa pun), dan Anda mengharapkan terlalu banyak dari 5 hari data. Anda benar-benar membutuhkan lebih banyak data untuk dapat mengatakan dengan signifikansi apa kesalahan dalam model Anda.
Aaron

Ada banyak parameter untuk menyesuaikan model. Saya mencoba beberapa dari mereka seperti penghentian awal (kesabaran = 20), peningkatan jumlah zaman, peningkatan satuan lstm dari 32 menjadi 64 dll. Hasilnya jauh lebih baik. periksa di sini github.com/jvishnuvardhan/Stackoverflow_Questions/blob/master/… . Seperti yang disebutkan oleh @sirjay menambahkan lebih banyak fitur (saat ini hanya 4), menambahkan lebih banyak layer (lstm, batchnorm, dropout, dll), menjalankan optimasi parameter hyper akan menghasilkan kinerja yang jauh lebih baik.
Vishnuvardhan Janapati

@VishnuvardhanJanapati terima kasih telah memeriksa. Saya mengkompilasi kode Anda, menyimpan model, lalu mengatur df.drop(df.tail(10).index, inplace=True), itu menunjukkan hasil buruk yang sama seperti yang saya miliki.
sirjay

Jawaban:


5

OP mendalilkan temuan yang menarik. Biarkan saya menyederhanakan pertanyaan awal sebagai berikut.

Jika model dilatih pada deret waktu tertentu, mengapa model tidak dapat merekonstruksi data deret waktu sebelumnya, yang sudah dilatih sebelumnya?

Nah, jawabannya tertanam dalam kemajuan pelatihan itu sendiri. Karena EarlyStoppingdigunakan di sini untuk menghindari overfitting, model terbaik disimpan di epoch=5, di mana val_loss=0.0030sebagaimana disebutkan oleh OP. Pada contoh ini, kehilangan pelatihan sama dengan 0.0343, yaitu, RMSE pelatihan 0.185. Karena dataset diskalakan menggunakan MinMaxScalar, kita perlu membatalkan penskalaan RMSE untuk memahami apa yang terjadi.

Nilai minimum dan maksimum dari urutan waktu ditemukan menjadi 2290dan 3380. Oleh karena itu, memiliki 0.185sebagai RMSE pelatihan berarti bahwa, bahkan untuk set pelatihan, nilai-nilai yang diprediksi dapat berbeda dari nilai-nilai kebenaran tanah sekitar 0.185*(3380-2290), yaitu ~200unit rata-rata.

Ini menjelaskan mengapa ada perbedaan besar ketika memprediksi data pelatihan itu sendiri pada langkah waktu sebelumnya.

Apa yang harus saya lakukan untuk meniru data pelatihan dengan sempurna?

Saya mengajukan pertanyaan ini dari diri saya sendiri. Jawaban sederhananya adalah, buat kehilangan latihan semakin dekat 0, yaitu overfit modelnya.

Setelah beberapa pelatihan, saya menyadari bahwa model dengan hanya 1 lapisan LSTM yang memiliki 32sel tidak cukup kompleks untuk merekonstruksi data pelatihan. Oleh karena itu, saya telah menambahkan lapisan LSTM lainnya sebagai berikut.

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

Dan model itu dilatih untuk 1000zaman tanpa mempertimbangkan EarlyStopping.

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

Pada akhir 1000zaman kita mengalami kehilangan pelatihan 0.00047yang jauh lebih rendah daripada hilangnya pelatihan dalam kasus Anda. Jadi kita akan mengharapkan model untuk merekonstruksi data pelatihan dengan lebih baik. Berikut ini adalah plot prediksi untuk 2-8 April.

ramalan

Catatan Akhir:

Pelatihan pada basis data tertentu tidak berarti bahwa model tersebut harus dapat merekonstruksi data pelatihan dengan sempurna. Terutama, ketika metode seperti penghentian awal, regularisasi dan dropout diperkenalkan untuk menghindari overfitting, model cenderung lebih digeneralisasikan daripada menghafal data pelatihan.


2

Mengapa model menunjukkan hasil yang salah pada data terlatihnya sendiri? Saya melatih data, harus ingat bagaimana memprediksi data pada set ini, tetapi memprediksi salah.

Anda ingin model mempelajari hubungan antara input dan output alih-alih menghafal. Jika suatu model menghafal output yang benar untuk setiap input, kita dapat mengatakan itu terlalu pas dengan data pelatihan. Seringkali Anda dapat memaksa model untuk berpakaian berlebihan dengan menggunakan subkumpulan kecil data, jadi jika itu perilaku yang ingin Anda lihat, Anda bisa mencobanya.


2

Tersangka # 1 - Regularisasi

Jaringan saraf sangat bagus dalam overfitting data pelatihan, sebenarnya ada percobaan mengganti label CIFAR10 (tugas klasifikasi gambar) (nilai y) dengan label acak pada set data pelatihan dan jaringan sesuai dengan label acak yang menghasilkan kehilangan hampir nol.

masukkan deskripsi gambar di sini

di sisi kiri kita dapat melihat bahwa diberi label zaman yang cukup acak mendapat sekitar 0 kerugian - skor sempurna (dari memahami pembelajaran yang mendalam membutuhkan generalisasi berpikir ulang oleh zhang et al 2016 )

Jadi mengapa itu tidak terjadi setiap saat? regularisasi .

regularisasi adalah (kira-kira) mencoba memecahkan masalah yang lebih sulit daripada masalah optimisasi (kerugian) yang kita tentukan untuk model.

beberapa metode pengaturan umum dalam jaringan saraf:

  • berhenti lebih awal
  • keluar
  • normalisasi batch
  • penurunan berat badan (mis. norma l1 l2)
  • augmentasi data
  • menambahkan noise acak / gaussian

metode ini membantu mengurangi overfitting dan biasanya menghasilkan validasi dan kinerja tes yang lebih baik, tetapi menghasilkan kinerja kereta yang lebih rendah (yang sebenarnya tidak masalah seperti yang dijelaskan pada paragraf terakhir).

melatih kinerja data biasanya tidak begitu penting dan untuk itu kami menggunakan set validasi.

Suspect # 2 - Ukuran Model

Anda menggunakan lapisan LSTM tunggal dengan 32 unit. itu cukup kecil. coba tambah ukuran dan bahkan letakkan dua layer LSTM (atau dua bidirectional) dan saya yakin model dan optimizer akan menyesuaikan data Anda selama Anda membiarkannya - yaitu menghapus penghentian awal, restore_last_weights dan regularisasi lain yang ditentukan di atas.

Catatan tentang Kompleksitas Masalah

mencoba untuk memprediksi harga saham di masa depan hanya dengan melihat sejarah bukanlah tugas yang mudah, dan bahkan jika model dapat (lebih) pas dengan pelatihan yang ditetapkan itu mungkin tidak akan melakukan apa pun yang berguna pada set tes atau di dunia nyata.

ML bukan ilmu hitam, x sampel perlu dikorelasikan dengan beberapa cara dengan tag y, kita biasanya menganggap bahwa (x, y) diambil dari beberapa distribusi bersama.

Cara yang lebih intuitif untuk memikirkannya, ketika Anda perlu menandai gambar secara manual untuk kelas anjing / kucing - itu cukup mudah. tetapi bisakah Anda secara manual "menandai" harga saham dengan melihat sejarah saham itu saja?

Itulah beberapa intuisi tentang betapa sulitnya masalah ini.

Catatan tentang Overfitting

Seseorang seharusnya tidak mengejar kinerja pelatihan yang lebih tinggi , hampir tidak berguna untuk mencoba menyesuaikan data pelatihan, karena kami biasanya mencoba untuk melakukan dengan baik dengan model pada data baru yang tidak terlihat dengan sifat yang mirip dengan data kereta. ide semua adalah untuk mencoba menggeneralisasi dan mempelajari sifat-sifat data dan korelasi dengan target, itulah pembelajarannya :)


2

Seperti yang sudah dikatakan orang lain, Anda seharusnya tidak berharap banyak dari ini.

Namun demikian, saya menemukan yang berikut ini dalam kode Anda:

  1. Anda memasang kembali scaler setiap kali selama pelatihan dan pengujian. Anda perlu menyimpan sacler dan hanya mengubah data selama pengujian, jika tidak, hasilnya akan sedikit berbeda:

    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. Setel shuffle=False. Karena Anda memang perlu menjaga urutan dataset Anda.

  3. Setel batch_size=1. Karena itu akan kurang rawan overfitting dan pembelajaran akan lebih berisik dan kesalahan kurang rata-rata.

  4. Atur epochs=50atau lebih.


Dengan pengaturan yang disebutkan di atas, model tercapai loss: 0.0037 - val_loss: 3.7329e-04 .

Periksa sampel prediksi berikut:

Dari 17/04/2020 -> 23/04/2020:

masukkan deskripsi gambar di sini

Dari 02/04/2020 -> 08/04/2020:

masukkan deskripsi gambar di sini

Dari 25/03/2020 -> 31/03/2020:

masukkan deskripsi gambar di sini


1

Pada dasarnya Jika Anda ingin mendapatkan hasil yang lebih baik untuk data pelatihan, akurasi pelatihan Anda harus setinggi mungkin. Anda harus menggunakan model yang lebih baik sehubungan dengan data yang Anda miliki. Pada dasarnya Anda harus memeriksa apakah akurasi pelatihan Anda untuk tujuan ini terlepas dari akurasi tes. Ini juga disebut sebagai overfitting yang memberikan akurasi yang lebih baik dalam data pelatihan daripada data uji.

Menghentikan lebih awal mungkin mempengaruhi skenario ini di mana akurasi tes / validasi terbaik diambil daripada akurasi pelatihan.


1

Jawaban singkatnya:

Set:

batch_size = 1
epochs = 200
shuffle = False

Intuisi: Anda menggambarkan prioritas akurasi tinggi dalam data pelatihan. Ini menggambarkan overfitting. Untuk melakukan itu, atur ukuran bets ke 1, zaman tinggi, dan mundur.


1

Setelah mengubah arsitektur model dan pengoptimal ke Adagrad, saya dapat meningkatkan hasilnya sampai batas tertentu.

Alasan menggunakan pengoptimal Adagrad di sini adalah:

Ini menyesuaikan tingkat pembelajaran dengan parameter, melakukan pembaruan yang lebih kecil (yaitu tingkat belajar yang rendah) untuk parameter yang terkait dengan fitur yang sering terjadi, dan pembaruan yang lebih besar (yaitu tingkat pembelajaran yang tinggi) untuk parameter yang terkait dengan fitur yang jarang terjadi. Untuk alasan ini, sangat cocok untuk berurusan dengan data yang jarang.

Silakan lihat kode di bawah ini:

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

Prediksi stok adalah tugas yang sangat menantang sehingga daripada tetap berpegang pada prediksi model tunggal, kita dapat meminta beberapa model bekerja sama untuk membuat prediksi dan kemudian berdasarkan hasil pemungutan suara yang maksimum, seperti pendekatan pembelajaran ensemble. Selain itu, kami dapat menumpuk beberapa model bersama seperti:

  1. Deep Feed-forward Auto-Encoder Neural Network untuk mengurangi dimensi + Deep Neural Network Deep Recurrent + ARIMA + Regulator Gradien Penguat Ekstrim

  2. Adaboost + Mengantongi + Pohon Ekstra + Meningkatkan Gradien + Hutan Acak + XGB

Agen pembelajaran Reinforcement melakukan cukup baik dalam Prediksi Saham seperti:

  1. Agen perdagangan penyu
  2. Agen rata-rata bergerak
  3. Agen rolling sinyal
  4. Agen kebijakan-gradien
  5. Agen Q-learning
  6. Agen strategi-evolusi

Silakan temukan tautan yang sangat banyak akal di sini .


adam juga memiliki sifat-sifat ini, sebenarnya adam adalah semacam evolusi adagrad
ShmulikA

0

Mengapa model menunjukkan hasil yang salah pada data terlatihnya sendiri? Saya melatih data, harus ingat bagaimana memprediksi data pada set ini, tetapi memprediksi salah.

Lihat apa yang kamu lakukan:

  1. Membangun model dengan beberapa lapisan
  2. Model pelatihan dengan data training_data
  3. Saat Anda melatih model, semua parameter yang dapat dilatih dilatih (misalnya, bobot model dihemat)
  4. Bobot ini sekarang mewakili hubungan antara input dan output.
  5. Saat Anda memperkirakan data training_data yang sama lagi, model yang dilatih kali ini menggunakan bobot untuk mendapatkan output.
  6. Kualitas model Anda sekarang menentukan prediksi dan karenanya mereka berbeda dari hasil asli walaupun datanya sama.

0

Ini kurang pas dan untuk meningkatkan hal itu Anda perlu menambahkan neuron ke dalam lapisan tersembunyi Anda. !! Poin lainnya adalah mencoba fungsi aktivasi 'relu'. Sigmoid tidak memberikan hasil yang baik. Anda juga perlu mendefinisikan 'softmax' di lapisan output Anda.!


Kedengarannya seperti Anda menyimpan rahasia untuk memprediksi pasar. Apa lagi yang harus dia lakukan?
Daniel Scott

2
Softmax adalah untuk klasifikasi, itu masalah regresi.
ShmulikA

1
@DanielScott Anda tidak mengerti. Jauh di bawah (miliar lapisan di bawah) itu adalah masalah klasifikasi yang memutuskan antara laba atau rugi. Mengapa peduli untuk memprediksi deret waktu?
Sowmya
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.