Untuk memprediksi saham, kali ini kita hanya akan menggunakan bahasa Python. Mengapa demikian? Alasannya adalah saya belum menemukan library dan metode yang tepat jika menggunakan bahasa R. Sebenarnya bisa saja buat script sendiri di R, tapi effort nya tidak sebanding dibandingkan dengan Python yang sudah memiliki library Keras (tinggal pakai dan jalankan).

Kita akan melakukan beberapa jenis peramalan:

1. Peramalan dengan 1 variabel saja
2. Peramalan dengan semua variabel untuk meramal beberapa hari ke depan
3. Peramalan untuk semua rentang waktu

Peramalan dengan 1 variabel

Bahasa Python

# Mengimpor library yang diperlukan
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Mengimpor dataset
dataset_train = pd.read_excel('FB_training.xlsx')
training_set = dataset_train.iloc[:, 1:2].values

# Proses feature scaling
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
training_set_scaled = sc.fit_transform(training_set)

# Membuat prediksi dengan 60 time-window (3 bulan)
X_train = []
y_train = []
for i in range(60, training_set.shape[0]):
    X_train.append(training_set_scaled[i-60:i, 0])
    y_train.append(training_set_scaled[i, 0])
X_train, y_train = np.array(X_train), np.array(y_train)

# Reshaping
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))

# Mengimpor library Keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LSTM
from tensorflow.keras.layers import Dropout

# Mulai membuat RNN
Mesin_saham = Sequential()

# Menambah layer LSTM yang pertama dan Dropout regularisation 
Mesin_saham.add(LSTM(units = 50, return_sequences = True, input_shape = (X_train.shape[1], 1)))
Mesin_saham.add(Dropout(0.2))

# Menambah layer LSTM yang kedua dan Dropout regularisation 
Mesin_saham.add(LSTM(units = 50, return_sequences = True))
Mesin_saham.add(Dropout(0.2))

# Menambah layer LSTM yang ketiga dan Dropout regularisation 
Mesin_saham.add(LSTM(units = 50, return_sequences = True))
Mesin_saham.add(Dropout(0.2))

# Menambah layer LSTM yang keempat dan Dropout regularisation 
Mesin_saham.add(LSTM(units = 50))
Mesin_saham.add(Dropout(0.2))

# Menambahkan output layer
Mesin_saham.add(Dense(units = 1))

# Melihat rancangan network LSTM kita
Mesin_saham.summary()

# Compile RNN
Mesin_saham.compile(optimizer = 'adam', loss = 'mean_squared_error')

# Menjalankan RNN ke Training set
Mesin_saham.fit(X_train, y_train, epochs = 100, batch_size = 32)

# Mengimpor data saham sesungguhnya untuk Test set
dataset_test = pd.read_excel('FB_test.xlsx')
saham_real = dataset_test.iloc[:, 1:2].values

# Memprediksi harga saham
dataset_total = pd.concat((dataset_train['Open'], dataset_test['Open']), axis = 0)
inputs = dataset_total[len(dataset_total) - len(dataset_test) - 60:].values
inputs = inputs.reshape(-1,1)
inputs = sc.transform(inputs)
X_test = []
for i in range(60, saham_real.shape[0] + X_train.shape[1]):
    X_test.append(inputs[i-60:i, 0])
X_test = np.array(X_test)
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
predicted_stock_price = Mesin_saham.predict(X_test)
predicted_stock_price = sc.inverse_transform(predicted_stock_price)

# Visualisasi perbandingan hasil prediksi dan data sesunguhnya
plt.plot(saham_real, color = 'red', label = 'Harga saham Facebook sesungguhnya')
plt.plot(predicted_stock_price, color = 'blue', label = 'Harga saham Facebook prediksi')
plt.title('Prediksi harga saham Facebook')
plt.xlabel('Waktu')
plt.ylabel('Harga saham Facebook')
plt.legend()
plt.show()

Penjelasan:

• Line 2-4 mengimpor library dasar yang diperlukan.
• Line 7 mengimpor datasetnya.

Jika dieksekusi, maka tampilan datanya sebagai berikut

Kita memiliki beberapa kolom, antara lain:

1. Date = Tanggal di mana saham tersebut dibuka di bursa untuk diperjual belikan. Dalam jual beli saham, tidak dikenal weekends, sehingga hanya hari kerja saja.
2. Open = Harga di mana saham tersebut dibuka di hari tersebut
3. High = Harga tertinggi di hari tersebut
4. Low = Harga terendah di hari tersebut
5. Close = Harga penutupan di hari itu
6. Adj close = Adjusted closing price, artinya harga penutupan setelah mempertimbangkan faktor lain sebelum benar-benar ditutup di hari itu.

Kali ini kita hanya akan menggunakan variabel open (kolom kedua) untuk memprediksi harga saham. Pertanyaannya, apakah cukup hanya menggunakan 1 variabel saja? Tentu saja tidak, karena ada banyak faktor lain yang memmengaruhi harga saham. Namun, untuk memudahkan pembelajaran, kali ini kita mulai dengan 1 variabel saja dulu.

• Line 8 melakukan slicing, di mana kita hanya memerlukan variabel Open price, yaitu harga saat saham tersebut dibuka di hari tersebut.
• Jika kita eksekusi, maka tampilannya sebagai berikut:

• Line 11 mengimpor library untuk melakukan proses preprocessing dengan metode normalisasi. Jika pembaca awam tentang preprocessing, silakan klik artikel saya ini. Library yang kita import adalah MinMaxScaler
• Line 12 mendefinisikan objek sc untuk melakukan normalisasi. Perintah yang kita tuliskan adalah MinMaxScaler, kemudian diikuti dengan feature_range = (0,1) yang artinya rentangnya antara 0 (nilai minimum) hingga 1 (nilai maksimum). Tips: untuk mengetahui parameter apa saja yang diperlukan, cukup arahkan kursor ke MinMaxScaler kemudian ketikkan CTRL+i di spyder, nanti akan muncul layar bantuan.
• Line 13 mendefinisikan objek training_set_scaled yang merupakan objek untuk training_set di line 8 yang sudah melalui proses normalisasi. Perintah yang diperlukan adalah sc (objek sebelumnya di line 12) kemudian diikuti dengan method fit_transform untuk objek training_set.

Sekarang kita sudah memiliki objek training_set_scaled. Jika diklik variabelnya, maka tampak sebagai berikut:

Sekarang kita akan mulai mendefinisikan objek X_train dan y_train. Yang akan kita lakukan adalah memprediksi harga berdasarkan pada data masa lalu, yaitu 60 data harga saham periode sebelumnya.

• Line 16 dan 17 mendefinisikan objek X_train dan y_train yang berupa list kosong.
• Line 18-20 adalah proses mengisi list kosong X_train dan y_train. Yang kita lakukan adalah sebagai berikut:

1. Proses looping dimulai dari angka 60 hingga jumlah baris yang dimiliki oleh training_set. Untuk mengetahui jumlah baris training_set maka kita gunakan method shape untuk kolom, sehingga ditulis training_set.shape[0]. Tips: Jika kita tulis training_set.shape[1], kita justru menambahkan berdasarkan kolom (bukan baris).
2. X_train diisi dengan 60 baris pertama. Perintah [i-60:i] artinya baris ke [0:60], karena i dimulai dari 60. Kemudian diikuti dengan kolom ke 0 pada training_set_scaled (kolom opening price).
3. y_train diisi mulai dari baris ke 60 dan kolom ke nol pada training_set_scaled.

Saya harap pembaca bisa memahami logikanya. Jadi X_train sebagai data ke 0 (baris ke 1) digunakan untuk memprediksi y_train sebagai data ke 59 (baris ke 60).

• Line ke 21 adalah mengonversi X_train dan y_train tadi menjadi sebuah array. Mengapa harus kita ubah ke array? Karena RNN hanya menerima input berbentuk array. Kita bisa melakukannya dengan menggunakan perintah np.array.
• Line 24 adalah melakukan proses perubahan ukuran dimensi variabel X_train. Mengapa harus diubah ukurannya? Karena untuk menjadi input LSTM di Keras diperlukan input dengan bentuk 3D, sehingga ukuran 2 dimensi 1729×60 akan diubah menjadi 3 dimensi. Cara merubahnya adalah dengan menggunakan perintah np.reshape.

Aturan penulisan np.reshape bisa dilihat masuk ke help (arahkan kursor ke reshape lalu ketik CTRL+i di keyboard. Parameter yang diperlukan pertama adalah nama variabel yang akan direshape, yaitu X_train. Kemudian diikuti dengan 3 variabel lainnya (jumlah baris, jumlah kolom, jumlah prediktor). Karena kita hanya memiliki 1 prediktor (opening price), maka kita tuliskan 1 di parameter akhirnya.

Sekarang coba dieksekusi, maka sekarang X_train menjadi 3 dimensi. Tampilannya sebagai berikut:

• Line 27-30 mengimpor library TensorFlow yang diperlukan.
• Line 33 mulai membuat RNN-LSTM kita. Sequential adalah perintah pertama yang ahrus ditulis untuk menginisiasi pembuatan ANN (dalam hal ini adalah RNN).
• Line 36 membuat layer pertama RNN. Kita gunakan perintah add untuk membuat layer.

Kemudian selanjutnya kita tuliskan LSTM (karena kita ingin membuat LSTM untuk RNN kita. Selanjutnya kita tuliskan (dalam kurung tertutup) units=50 yang berarti kita menentukan jumlah neuronnya adalah 50. Penentuan jumlah neuron ini bebas ya.

Selanjutnya kita tuliskan return_sequences yang artinya hasil dari LSTM kita akan berlanjut ke LSTM selanjutnya. Secara otomatis nilai default nya adalah FALSE. Jika ingin menambah layer LSTM lagi, maka harus diubah menjadi TRUE.

Parameter selanjutnya adalah input_shape. Seperti yang dijelaskan sebelumnya, parameter ini memerlukan variabel 3 dimensi (batch_size, timesteps, input_dim) . Kita sudah memiliki X_train yang berdimensi 3, namun kali ini kita cukup tuliskan dua dimensi terakhir yang merupakan representasi dari (timesteps, input_dim). Walaupun kita tidak menuliskan lagi batch_size, ia akan secara otomatis terdeteksi oleh Keras dan mengasumsikannya sebagai 1 sample, di mana 1 batch_size terdiri dari beberapa sampel.

• Line 37 adalah menambahkan layer dropout dengan nilai 0.2. Penentuan angka 0.2 adalah yang biasa dipakai oleh pengguna LSTM. Apa tujuan dari dropout? Tujuannya adalah untuk menghindari overfitting.
• Line 40 dan 41 menambahkan layer yang sama seperti di line 36 dan 37. Perlu diperhatikan bahwa di line 36 kita tidak perlu menuliskan lagi input_shape, karena sudah didefinisikan sebelumnya.
• Line 44 dan 45 juga melakukan hal yang sama.
• Line 48 dan 49 adalah layer LSTM terakhir. Perlu diperhatikan bahwa kita tidak perlu menuliskan lagi return_sequences, karena secara default nilainya adalah FALSE.
• Line 52 adalah tahap mendefinisikan output layer. Kita hanya memerlukan 1 unit saja karena ini forecasting (peramalan) yang mirip regresi.
• Line 55 adalah perintah untuk melihat arsitektur LSTM kita. Jika dieksekusi tampilanya adalah sebagai berikut:

• Line 58 adalah persiapan sebelum kita latih LSTM kita. Parameter yang kita perlukan adalah optimizer menggunakan adam, dan kriteria loss nya adalah mean_squared_error.
• Line 61 adalah tahapan di mana RNN kita mulai belajar dari training set (X_train dan y_train). Kita tentukan epoch nya 100 dan batch_size nya adalah 32. Tentu saja penentuan nilai epoch ini bebas.

Sampai di sini kita cukup menunggu beberapa saat. Jika spesifikasi komputer pembaca cukup tinggi, maka bisa selesai kurang dari 30 menit. Tampilan iterasinya kurang lebih sebagai berikut:

• Line 64 adalah mengimpor test set kita.
• Line 65 kita melakukan slicing di mana hanya memerlukan kolom kedua saja (opening price) pada test set. Kitaberi nama variabelnya sebagai saham_real.
• Line 68 menggabungkan training set dan test set. Untuk menggabungkan kita guakan perintah pd.concat (kependekan dari Panda Concatenation). Karena kita inggin menggunakan penggabungan vertikal maka parameter axis=0. Jika ingin penggabungan horisontal, maka axis=1.
• Line 69 kita definisikan variabel dengan nama inputs. Kemudian kita isi inputs ini dengan data dari dataset_total 60 step mundur ke belakang (yang sebenarnya merupakan 60 data paling akhir yang dimiliki training set). Dengan menambahkan method values di belakangnya, maka kita tidak memerlukan headernya.
• Line 70 merubah dimensi inputs. Kita memerlukan kolom sebanyak 1 buah, oleh karena itu parameter paling akhir kita tulis 1. Trik untuk menentukan jumlah barisnya kita cukup tulis -1 di parameter awal, yang berarti Python akan mencari dimensinya sendiri secara otomatis.
• Line 71 adalah melakukan proses preprocessing untuk X_test kita nanti. Mengapa harus melalui preprocessing lagi? Karena X_train dan y_train kita juga melalui proses ini, begitu pula mesin_saham kita juga di train menggunakan skala ini, sehingga inputs sebagai sumber data dari X_test nantinya harus melalui proses preprocessing.
• Line 72 mendefinisikan variabel X_test sebagai sebuah list kosong.
• Line 73-74 adalah mengisi konten untuk variabel X_test. Penjelasannya mirip dengan line 18-20.
• Line 75 merubah X_test menjadi numpy array.
• Line 76 merubah dimensi X_test. Penjelasannya sama dengan line 24.
• Line 77 adalah proses bagaimana mesin_saham memprediksi nilai test set (X_set).
• Line 78 adalah mengembalikan lagi ke bentuk data awal (inverse dari preprocessing). Mengapa harus diinverse? Karena hasil prediksinya masih dalam format (skala) preprocessing (MinMaxScaler).
• Line 81-87 adalah proses plotting hasil prediksi. Jika dieksekusi, tampilannya adalah sebagai berikut:

Bisa dilihat pada gambar di atas, ternyata model kita cukup baik untuk memprediksi harga saham yang berada di test set. Walaupun masih ada jarak (selisih) antara harga sesungguhnya dengan harga prediksi, namun secara visual sudah cukup baik. Perlu diperhatikan bahwa model kita hanya belajar dari 1 prediktor (variabel) saja yaitu opening price.

Model yang dibuat ini masih bisa terus ditingkatkan. Jika pembaca ingin, maka bisa dilakukan dengan menambah layer LSTM, menambah epoch, merubah jenis proses preprocessing, menggunakan activation function yang lain, dan masih banyak lagi.

Di pembahasan ini kita belajar untuk memprediksi test set dari training set. Ternyata LSTM memiliki kemampuan untuk belajar dari informasi sebelumnya, karena memiliki memory (ingatan) yang menjadi dasar ia mengambil keputusan.

Di kesempatan selanjutnya saya akan berbagi bagaimana caranya memprediksi nilai saham beberapa hari ke depan.

Semoga pembaca mendapatkan manfaat dari pembahasan kali ini. Terus nantikan artikel-artikel dan tutorial tentang AI di website saya.

Jika ada pertanyaan, silakan tulis di bagian komentar.

Tetap semangat belajar AI !

Terima kasih.

Pages: 1 2