Terdapat tiga poin yang akan kita pelajari kali ini, yaitu:
- Sequence Downside
- RNN (Recurrent Neural Community)
- LSTM (Lengthy-Quick Time period Reminiscence)
Dalam sequence downside, urutan datapoint menjadi berarti. Untuk melakukan prediksi time-series, kita menggunakan knowledge dari pengalaman sebelumnya untuk memproses nilai masukkan berikutnya.
Mannequin Synthetic Neural Community (ANN) biasa, seperti MLP sebenarnya tidak dapat menyelesaikan permasalahan time-series dengan efektif. Meskipun demikian, mannequin ini masih dapat digunakan untuk kasus sederhana. Permasalahan time-series yang lebih kompleks atau advance lebih sering menggunakan RNN atau LSTM.
Mechanism and Draw back
RNN adalah jenis khusus rangkaian neural buatan yang diadaptasi untuk bekerja dengan knowledge berurutan atau sequence. RNN memiliki konsep memori yang membantu menyimpan keadaan atau informasi dari enter sebelumnya untuk menghasilkan output berikutnya dalam urutan tersebut.
Vanishing gradient points adalah salah satu kelemahan dari RNN. Mannequin RNN hanya mengingat knowledge yang paling baru meskipun memiliki konsep memori. Akibatnya, semakin panjang knowledge sekuens, semakin sulit pula untuk diprediksi secara akurat.
RNN Structure in TensorFlow
import tensorflow as tf
#Outline the RNN mannequin
mannequin = tf.keras.Sequential([
tf.keras.layers.SimpleRNN(units=64, activation='tanh', input_shape=(time_steps, features)),
])#Compile the mannequin
mannequin.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
#Show the mannequin abstract
mannequin.abstract()
LSTM adalah improvisasi lanjutan dari RNN yang dapat memahami hubungan jangka panjang. LSTM memiliki memori jangka panjang yang disebut sebagai “cell state” untuk mengatasi knowledge sequence yang panjang.
Beberapa bagian pada proses mannequin LSTM adalah sebagai berikut.
- Neglect gate: Informasi yang tidak lagi digunakan oleh cell state akan dihapus pada overlook gate.
- Enter gate: Informasi lain yang berguna bagi cell state akan dimasukkan pada enter gate.
- Output gate: Informasi yang berguna dari present cell state akan diekstrak pada output gate.
LSTM Structure in TensorFlow
import tensorflow as tf
from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import LSTM, Dense
#Sequential mannequin
mannequin = Sequential()#Add LSTM layer to mannequin
mannequin.add(LSTM(models=50, activation='relu', input_shape=(timesteps, options)))
#Add Dense layer for output
mannequin.add(Dense(models=output_dim))
#Compile the mannequin
mannequin.compile(optimizer='adam', loss='mean_squared_error')
#Practice the mannequin
mannequin.match(X_train, y_train, epochs=epochs, batch_size=batch_size)
Sama seperti prediksi time-series dengan model MLP, kita akan gunakan knowledge dari modul praktik.
Untuk mannequin CNN, kita akan gunakan sebuah convolutional hidden layer yang dilanjut dengan max pooling layer. Filter maps kita datarkan sebelum diinterpretasikan dense layer dan output. Convolutional layer harus dapat mengidentifikasi pola diantara timesteps.
Knowledge Preprocess
- Mengubah bentuk [sample, timesteps] menjadi [sample, timesteps, feature].
- Bentuk ini akan digunakan juga untuk mannequin LSTM.
X_train_series = X_train.values.reshape((X_train.form[0], X_train.form[1], 1))
X_valid_series = X_valid.values.reshape((X_valid.form[0], X_valid.form[1], 1))
print('Practice set form', X_train_series.form)
print('Validation set form', X_valid_series.form)
import tensorflow as tfmodel_cnn = Sequential()
model_cnn.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train_series.form[1], X_train_series.form[2])))
model_cnn.add(MaxPooling1D(pool_size=2))
model_cnn.add(Flatten())
model_cnn.add(Dense(50, activation='relu'))
model_cnn.add(Dense(1))
model_cnn.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001))
model_cnn.abstract()
Output:
cnn_history = model_cnn.match(X_train_series, Y_train, validation_data=(X_valid_series, Y_valid), epochs=epochs, verbose=2)
Mannequin LSTM akan membaca enter knowledge sebagai knowledge sequence, jadi ini memungkinkan untuk membaca pola knowledge sekuensial lebih baik terutama pada knowledge sekuensial yang panjang. Bentuk enter [sample, timesteps, features].
model_lstm = Sequential()
model_lstm.add(LSTM(50, activation='relu', input_shape=(X_train_series.form[1], X_train_series.form[2])))
model_lstm.add(Dense(1))
model_lstm.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001))
model_lstm.abstract()
Output:
lstm_history = model_lstm.match(X_train_series, Y_train, validation_data=(X_valid_series, Y_valid), epochs=epochs, verbose=2)
Mannequin ini akan membaca/menafsirkan setiap rangkaian (CNN)lalu menyusun semula interpretasi dari setiap sub-rangkaian tersebut (LSTM).
CNN akan didefinisikan untuk mengharapkan 2 timesteps per sub-rangkaian dengan satu options. Keseluruhan mannequin CNN akan dilapisi dengan lapisan TimeDistributed supaya dapat digunakan pada setiap sub-rangkaian dalam sampel. Hasilnya diinterpretasi oleh LSTM sebelum mannequin mengeluarkan output forecasting.
Knowledge Preprocess
- Mengubah bentuk [samples, timesteps, features] ke dalam [samples, subsequences, timesteps, features].
subsequences = 2
timesteps = X_train_series.form[1]//subsequences
X_train_series_sub = X_train_series.reshape((X_train_series.form[0], subsequences, timesteps, 1))
X_valid_series_sub = X_valid_series.reshape((X_valid_series.form[0], subsequences, timesteps, 1))
print('Practice set form', X_train_series_sub.form)
print('Validation set form', X_valid_series_sub.form)
model_cnn_lstm = Sequential()
model_cnn_lstm.add(TimeDistributed(Conv1D(filters=64, kernel_size=1, activation='relu'), input_shape=(None, X_train_series_sub.form[2], X_train_series_sub.form[3])))
model_cnn_lstm.add(TimeDistributed(MaxPooling1D(pool_size=2)))
model_cnn_lstm.add(TimeDistributed(Flatten()))
model_cnn_lstm.add(LSTM(50, activation='relu'))
model_cnn_lstm.add(Dense(1))
model_cnn_lstm.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001))
cnn_lstm_history = model_cnn_lstm.match(X_train_series_sub, Y_train, validation_data=(X_valid_series_sub, Y_valid), epochs=epochs, verbose=2)
Kita akan membandingkan prepare loss dan validation loss untuk mannequin MLP, mannequin CNN, mannequin LSTM, dan mannequin CNN-LSTM.
fig, axes = plt.subplots(2, 2, sharex=True, sharey=True,figsize=(22,12))
ax1, ax2 = axes[0]
ax3, ax4 = axes[1]ax1.plot(mlp_history.historical past['loss'], label='Practice loss')
ax1.plot(mlp_history.historical past['val_loss'], label='Validation loss')
ax1.legend(loc='finest')
ax1.set_title('MLP')
ax1.set_xlabel('Epochs')
ax1.set_ylabel('MSE')
ax2.plot(cnn_history.historical past['loss'], label='Practice loss')
ax2.plot(cnn_history.historical past['val_loss'], label='Validation loss')
ax2.legend(loc='finest')
ax2.set_title('CNN')
ax2.set_xlabel('Epochs')
ax2.set_ylabel('MSE')
ax3.plot(lstm_history.historical past['loss'], label='Practice loss')
ax3.plot(lstm_history.historical past['val_loss'], label='Validation loss')
ax3.legend(loc='finest')
ax3.set_title('LSTM')
ax3.set_xlabel('Epochs')
ax3.set_ylabel('MSE')
ax4.plot(cnn_lstm_history.historical past['loss'], label='Practice loss')
ax4.plot(cnn_lstm_history.historical past['val_loss'], label='Validation loss')
ax4.legend(loc='finest')
ax4.set_title('CNN-LSTM')
ax4.set_xlabel('Epochs')
ax4.set_ylabel('MSE')
plt.present()
Output:
Terlihat bahwa mannequin CNN-LSTM memiliki prepare loss dan validation loss yang mirip, artinya mannequin ini paling baik dalam forecasting dibandingkan tiga mannequin lainnya.
Be taught Extra by way of myskill.id/course/time-series-prediction-lstm
