Time Series Prediction LSTM series from Python For Data Science Learning Path MySkill.id
Yuk subscribe untuk mendapatkan email notifikasi setiap ada artikel terbaru oleh MySkill.
Terdapat tiga poin yang akan kita pelajari kali ini, yaitu:
- Sequence Problem
- RNN (Recurrent Neural Network)
- LSTM (Long-Short Term Memory)
Sequence Problem
Dalam sequence problem, urutan datapoint menjadi berarti. Untuk melakukan prediksi time-series, kita menggunakan data dari pengalaman sebelumnya untuk memproses nilai masukkan berikutnya.
Model Artificial Neural Network (ANN) biasa, seperti MLP sebenarnya tidak dapat menyelesaikan permasalahan time-series dengan efektif. Meskipun demikian, model ini masih dapat digunakan untuk kasus sederhana. Permasalahan time-series yang lebih kompleks atau advance lebih sering menggunakan RNN atau LSTM.
RNN (Recurrent Neural Network)
Mechanism and Downside
RNN adalah jenis khusus rangkaian neural buatan yang diadaptasi untuk bekerja dengan data berurutan atau sequence. RNN memiliki konsep memori yang membantu menyimpan keadaan atau informasi dari input sebelumnya untuk menghasilkan output berikutnya dalam urutan tersebut.
Vanishing gradient issues adalah salah satu kelemahan dari RNN. Model RNN hanya mengingat data yang paling baru meskipun memiliki konsep memori. Akibatnya, semakin panjang data sekuens, semakin sulit pula untuk diprediksi secara akurat.
RNN Architecture in TensorFlow
import tensorflow as tf
#Define the RNN model
model = tf.keras.Sequential([
tf.keras.layers.SimpleRNN(units=64, activation='tanh', input_shape=(time_steps, features)),
])
#Compile the model
model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
#Display the model summary
model.summary()LSTM (Long-Short Term Memory)
LSTM adalah improvisasi lanjutan dari RNN yang dapat memahami hubungan jangka panjang. LSTM memiliki memori jangka panjang yang disebut sebagai “cell state” untuk mengatasi data sequence yang panjang.
Beberapa bagian pada proses model LSTM adalah sebagai berikut.
- Forget gate: Informasi yang tidak lagi digunakan oleh cell state akan dihapus pada forget gate.
- Input gate: Informasi lain yang berguna bagi cell state akan dimasukkan pada input gate.
- Output gate: Informasi yang berguna dari current cell state akan diekstrak pada output gate.
LSTM Architecture in TensorFlow
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
#Sequential model
model = Sequential()
#Add LSTM layer to model
model.add(LSTM(units=50, activation='relu', input_shape=(timesteps, features)))
#Add Dense layer for output
model.add(Dense(units=output_dim))
#Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')
#Train the model
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size)CNN for Time-Series Forecasting
Sama seperti prediksi time-series dengan model MLP, kita akan gunakan data dari modul praktik.
Untuk model 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.
Data Preprocess
- Mengubah bentuk [sample, timesteps] menjadi [sample, timesteps, feature].
- Bentuk ini akan digunakan juga untuk model LSTM.
X_train_series = X_train.values.reshape((X_train.shape[0], X_train.shape[1], 1))
X_valid_series = X_valid.values.reshape((X_valid.shape[0], X_valid.shape[1], 1))
print('Train set shape', X_train_series.shape)
print('Validation set shape', X_valid_series.shape)import tensorflow as tf
model_cnn = Sequential()
model_cnn.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(X_train_series.shape[1], X_train_series.shape[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.summary()Output:
cnn_history = model_cnn.fit(X_train_series, Y_train, validation_data=(X_valid_series, Y_valid), epochs=epochs, verbose=2)LSTM for Time-Series Forecasting
Model LSTM akan membaca input data sebagai data sequence, jadi ini memungkinkan untuk membaca pola data sekuensial lebih baik terutama pada data sekuensial yang panjang. Bentuk input [sample, timesteps, features].
model_lstm = Sequential()
model_lstm.add(LSTM(50, activation='relu', input_shape=(X_train_series.shape[1], X_train_series.shape[2])))
model_lstm.add(Dense(1))
model_lstm.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001))
model_lstm.summary()Output:
lstm_history = model_lstm.fit(X_train_series, Y_train, validation_data=(X_valid_series, Y_valid), epochs=epochs, verbose=2)CNN-LSTM for Time-Series Forecasting
Model 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 features. Keseluruhan model CNN akan dilapisi dengan lapisan TimeDistributed supaya dapat digunakan pada setiap sub-rangkaian dalam sampel. Hasilnya diinterpretasi oleh LSTM sebelum model mengeluarkan output forecasting.
Data Preprocess
- Mengubah bentuk [samples, timesteps, features] ke dalam [samples, subsequences, timesteps, features].
subsequences = 2
timesteps = X_train_series.shape[1]//subsequences
X_train_series_sub = X_train_series.reshape((X_train_series.shape[0], subsequences, timesteps, 1))
X_valid_series_sub = X_valid_series.reshape((X_valid_series.shape[0], subsequences, timesteps, 1))
print('Train set shape', X_train_series_sub.shape)
print('Validation set shape', X_valid_series_sub.shape)model_cnn_lstm = Sequential()
model_cnn_lstm.add(TimeDistributed(Conv1D(filters=64, kernel_size=1, activation='relu'), input_shape=(None, X_train_series_sub.shape[2], X_train_series_sub.shape[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.fit(X_train_series_sub, Y_train, validation_data=(X_valid_series_sub, Y_valid), epochs=epochs, verbose=2)Comparison of Each Models
Kita akan membandingkan train loss dan validation loss untuk model MLP, model CNN, model LSTM, dan model 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.history['loss'], label='Train loss')
ax1.plot(mlp_history.history['val_loss'], label='Validation loss')
ax1.legend(loc='best')
ax1.set_title('MLP')
ax1.set_xlabel('Epochs')
ax1.set_ylabel('MSE')
ax2.plot(cnn_history.history['loss'], label='Train loss')
ax2.plot(cnn_history.history['val_loss'], label='Validation loss')
ax2.legend(loc='best')
ax2.set_title('CNN')
ax2.set_xlabel('Epochs')
ax2.set_ylabel('MSE')
ax3.plot(lstm_history.history['loss'], label='Train loss')
ax3.plot(lstm_history.history['val_loss'], label='Validation loss')
ax3.legend(loc='best')
ax3.set_title('LSTM')
ax3.set_xlabel('Epochs')
ax3.set_ylabel('MSE')
ax4.plot(cnn_lstm_history.history['loss'], label='Train loss')
ax4.plot(cnn_lstm_history.history['val_loss'], label='Validation loss')
ax4.legend(loc='best')
ax4.set_title('CNN-LSTM')
ax4.set_xlabel('Epochs')
ax4.set_ylabel('MSE')
plt.show()Output:
Terlihat bahwa model CNN-LSTM memiliki train loss dan validation loss yang mirip, artinya model ini paling baik dalam forecasting dibandingkan tiga model lainnya.
Learn More via myskill.id/course/time-series-prediction-lstm
