Penerjemah Polina Kabirova khusus untuk Netologia mengadaptasi sebuah artikel oleh Insinyur Universitas Cambridge Vivek Palaniappan tentang cara membuat model menggunakan jaringan saraf yang dapat memprediksi harga saham di bursa saham.Mesin dan pembelajaran mendalam telah menjadi strategi baru yang efektif yang digunakan banyak dana investasi untuk meningkatkan pendapatan. Dalam artikel itu, saya akan menjelaskan bagaimana jaringan saraf membantu memprediksi situasi di pasar saham - misalnya, harga saham (atau indeks). Teks ini didasarkan pada
proyek saya yang ditulis dengan Python. Kode lengkap dan panduan program dapat ditemukan di GitHub. Baca artikel terkait lainnya di Blog
Sedang .
Jaringan saraf dalam bidang ekonomi
Perubahan dalam bidang keuangan tidak linier, dan kadang-kadang mungkin terlihat bahwa harga saham dibentuk sepenuhnya secara acak. Metode deret waktu tradisional, seperti model ARIMA dan GARCH, efektif ketika rangkaian stasioner - sifat dasarnya tidak berubah seiring waktu. Dan ini mengharuskan seri telah diproses sebelumnya menggunakan
log returns atau dibawa ke stasioneritas berbeda. Namun, masalah utama muncul ketika model ini diimplementasikan dalam sistem perdagangan nyata, karena stasioneritas tidak dijamin saat menambahkan data baru.
Solusi untuk masalah ini dapat berupa jaringan saraf yang tidak memerlukan stasioneritas. Jaringan saraf pada awalnya sangat efektif dalam menemukan hubungan antara data dan mampu memprediksi (atau mengklasifikasikan) data baru berdasarkan mereka.
Biasanya, proyek ilmu data terdiri dari operasi berikut:
- Pengumpulan data - menyediakan sekumpulan properti yang diperlukan.
- Preprocessing data seringkali merupakan langkah yang menakutkan tetapi perlu sebelum menggunakan data.
- Pengembangan dan implementasi model adalah pilihan jenis jaringan saraf dan parameternya.
- Model backtesting (pengujian pada data historis) adalah langkah kunci dalam strategi perdagangan apa pun.
- Optimasi - mencari parameter yang sesuai.
Input untuk jaringan saraf kami - data tentang harga saham selama 10 hari terakhir. Dengan bantuan mereka, kami akan memperkirakan harga pada hari berikutnya.
Pengumpulan data
Untungnya, data yang dibutuhkan untuk proyek ini dapat ditemukan di Yahoo Finance. Data dapat dikumpulkan menggunakan API Python
pdr.get_yahoo_data(ticker, start_date, end_date) atau langsung dari situs.
Pra-pemrosesan data
Dalam kasus kami, data perlu dibagi ke dalam set pelatihan yang terdiri dari 10 harga sebelumnya dan harga hari berikutnya. Untuk melakukan ini, saya mendefinisikan kelas
Preprocessing , yang akan bekerja dengan data pelatihan dan tes. Di dalam kelas, saya mendefinisikan metode
get_train(self, seq_len) , yang mengubah data input dan output pelatihan menjadi array
NumPy , menetapkan panjang jendela tertentu (dalam kasus kami 10). Seluruh kode terlihat seperti ini:
def gen_train(self, seq_len): """ Generates training data :param seq_len: length of window :return: X_train and Y_train """ for i in range((len(self.stock_train)//seq_len)*seq_len - seq_len - 1): x = np.array(self.stock_train.iloc[i: i + seq_len, 1]) y = np.array([self.stock_train.iloc[i + seq_len + 1, 1]], np.float64) self.input_train.append(x) self.output_train.append(y) self.X_train = np.array(self.input_train) self.Y_train = np.array(self.output_train)
Demikian pula, saya telah mendefinisikan metode yang mengkonversi data uji
X_test dan
Y_test .
Model Jaringan Saraf Tiruan
Untuk proyek ini, saya menggunakan dua model jaringan saraf: Multilayer Perceptron (MLP) dan Long Short Term Model (LSTM). Saya akan berbicara singkat tentang cara kerja model ini. Baca lebih lanjut tentang MLP di
artikel lain , dan tentang karya LSTM di Jacob Aungiers.
MLP adalah bentuk paling sederhana dari jaringan saraf. Input data masuk ke dalam model dan menggunakan bobot tertentu, nilai-nilai ditransmisikan melalui lapisan tersembunyi untuk mendapatkan data output. Mempelajari algoritma berasal dari propagasi balik melalui lapisan tersembunyi untuk mengubah nilai bobot masing-masing neuron. Masalah dengan model ini adalah kurangnya "memori." Tidak mungkin untuk menentukan apa data sebelumnya dan bagaimana hal itu dapat dan harus mempengaruhi yang baru. Dalam konteks model kami, perbedaan 10 hari antara data dari dua set data mungkin penting, tetapi MLP tidak dapat menganalisis hubungan tersebut.
Untuk melakukan ini, gunakan LSTM atau Jaringan Syaraf Berulang (RNN). RNN menyimpan informasi data tertentu untuk digunakan nanti, ini membantu jaringan saraf menganalisis struktur kompleks hubungan antara data harga saham. Tetapi dengan RNN, masalah gradien pudar muncul. Gradien berkurang karena jumlah lapisan meningkat dan tingkat pelatihan (nilai kurang dari satu) dikalikan beberapa kali. Selesaikan masalah LSTM ini dengan meningkatkan efisiensi.
Implementasi model
Untuk mengimplementasikan model, saya menggunakan
Keras , karena ada lapisan yang ditambahkan secara bertahap, dan tidak mendefinisikan seluruh jaringan sekaligus. Jadi kita dapat dengan cepat mengubah jumlah dan jenis lapisan, mengoptimalkan jaringan saraf.
Langkah penting dalam bekerja dengan harga saham adalah normalisasi data. Biasanya untuk ini Anda mengurangi kesalahan rata-rata dan membaginya dengan kesalahan standar. Tetapi kita membutuhkan sistem ini untuk digunakan dalam perdagangan nyata untuk periode waktu tertentu. Jadi, menggunakan statistik mungkin bukan cara paling akurat untuk menormalkan data. Jadi saya hanya membagi semua data menjadi 200 (angka sewenang-wenang dibandingkan dengan semua angka lainnya kecil). Dan walaupun tampaknya normalisasi seperti itu tidak dibenarkan dan tidak masuk akal, efektif untuk memastikan bahwa bobot dalam jaringan saraf tidak menjadi terlalu besar.
Mari kita mulai dengan model yang lebih sederhana - MLP. Keras membangun urutan dan menambahkan lapisan padat di atasnya. Kode lengkapnya terlihat seperti ini:
model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu)) model.compile(optimizer="adam", loss="mean_squared_error")
Menggunakan Keras dalam lima baris kode, kami menciptakan MLP dengan lapisan tersembunyi, masing-masing seratus neuron. Dan sekarang sedikit tentang pengoptimal. Metode Adam (estimasi momen adaptif) mendapatkan popularitas - algoritma optimasi yang lebih efisien dibandingkan dengan
penurunan gradien stokastik . Ada dua ekstensi lain dari penurunan gradien stokastik - Keuntungan Adam segera terlihat dengan latar belakang mereka:
AdaGrad - mempertahankan kecepatan belajar yang ditetapkan, yang meningkatkan hasil ketika gradien berbeda (misalnya, dengan masalah dengan bahasa alami dan visi komputer).
RMSProp - mempertahankan kecepatan pelatihan yang ditetapkan, yang dapat bervariasi tergantung pada nilai rata-rata gradien terbaru untuk berat (misalnya, seberapa cepat itu berubah). Ini berarti bahwa algoritme mengatasi dengan baik dengan masalah non-stasioner (misalnya, kebisingan).
Adam menggabungkan manfaat ekstensi ini, jadi saya memilihnya.
Sekarang kami menyesuaikan model dengan data pelatihan kami. Keras menyederhanakan tugas lagi, hanya kode berikut yang diperlukan:
model.fit(X_train, Y_train, epochs=100)
Saat model siap, Anda perlu memeriksanya pada data uji untuk menentukan seberapa baik kerjanya. Ini dilakukan seperti ini:
model.evaluate(X_test, Y_test)
Informasi yang diperoleh dari verifikasi dapat digunakan untuk menilai kemampuan model untuk memprediksi harga saham.
Prosedur serupa digunakan untuk model LSTM, jadi saya akan menunjukkan kode dan sedikit menjelaskannya:
model = tf.keras.Sequential() model.add(tf.keras.layers.LSTM(20, input_shape=(10, 1), return_sequences=True)) model.add(tf.keras.layers.LSTM(20)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu)) model.compile(optimizer="adam", loss="mean_squared_error") model.fit(X_train, Y_train, epochs=50) model.evaluate(X_test, Y_test)
Harap perhatikan bahwa Keras membutuhkan data dengan ukuran tertentu, tergantung pada model Anda. Sangat penting untuk mengubah bentuk array menggunakan NumPy.
Model Backtesting
Ketika kami menyiapkan model kami menggunakan data pelatihan dan mengujinya pada data uji, kami dapat menguji model pada data historis. Ini dilakukan sebagai berikut:
def back_test(strategy, seq_len, ticker, start_date, end_date, dim): """ A simple back test for a given date period :param strategy: the chosen strategy. Note to have already formed the model, and fitted with training data. :param seq_len: length of the days used for prediction :param ticker: company ticker :param start_date: starting date :type start_date: "YYYY-mm-dd" :param end_date: ending date :type end_date: "YYYY-mm-dd" :param dim: dimension required for strategy: 3dim for LSTM and 2dim for MLP :type dim: tuple :return: Percentage errors array that gives the errors for every test in the given date range """ data = pdr.get_data_yahoo(ticker, start_date, end_date) stock_data = data["Adj Close"] errors = [] for i in range((len(stock_data)//10)*10 - seq_len - 1): x = np.array(stock_data.iloc[i: i + seq_len, 1]).reshape(dim) / 200 y = np.array(stock_data.iloc[i + seq_len + 1, 1]) / 200 predict = strategy.predict(x) while predict == 0: predict = strategy.predict(x) error = (predict - y) / 100 errors.append(error) total_error = np.array(errors) print(f"Average error = {total_error.mean()}")
Namun, ini adalah versi pengujian yang disederhanakan. Untuk sistem backtesting lengkap, faktor-faktor seperti "bias survivorship", bias (lihat bias depan), perubahan kondisi pasar dan biaya transaksi harus dipertimbangkan. Karena ini hanya proyek pendidikan, uji coba sederhana sudah cukup.
Perkiraan model LSTM saya untuk harga saham Apple pada bulan FebruariUntuk model LSTM sederhana tanpa optimasi, ini adalah hasil yang sangat bagus. Ini menunjukkan bahwa jaringan saraf dan model pembelajaran mesin mampu membangun koneksi yang kompleks dan stabil antar parameter.
Optimalisasi Hyperparameter
Optimasi sering diperlukan untuk meningkatkan hasil model setelah pengujian. Saya tidak memasukkannya dalam versi open source sehingga pembaca dapat mencoba untuk mengoptimalkan model itu sendiri. Mereka yang tidak tahu cara mengoptimalkan harus menemukan hyperparameter yang akan meningkatkan kinerja model. Ada beberapa metode untuk menemukan hiperparameter: dari memilih parameter pada grid hingga metode stokastik.
Saya yakin bahwa dengan optimalisasi model, pengetahuan di bidang pembelajaran mesin naik ke tingkat yang baru. Cobalah untuk mengoptimalkan model sehingga itu berfungsi lebih baik daripada milikku. Bandingkan hasilnya dengan grafik di atas.
Kesimpulan
Pembelajaran mesin terus berkembang - metode baru muncul setiap hari, jadi sangat penting untuk terus belajar. Cara terbaik untuk melakukan ini adalah membuat proyek yang menarik, misalnya, membangun model untuk memperkirakan harga saham. Dan meskipun model LSTM saya tidak cukup baik untuk digunakan dalam perdagangan nyata, dasar yang diletakkan dalam pengembangan model seperti itu dapat membantu di masa depan.
Dari para editor
Mata kuliah Netologi dengan topik: