Prediksi harga Bitcoin secara real-time menggunakan LSM Framework

Hint: Kasus ini hanya untuk tujuan penelitian dan tidak merupakan rekomendasi investasi.

Data harga Bitcoin didasarkan pada urutan waktu, sehingga prediksi harga Bitcoin sebagian besar dilakukan dengan menggunakan model LSTM.

Memori jangka pendek panjang (LSTM) adalah model pembelajaran mendalam yang sangat cocok untuk data urutan waktu (atau data dengan urutan waktu/ruang/struktur, seperti film, kalimat, dll.) dan merupakan model ideal untuk memprediksi arah harga cryptocurrency.

Artikel ini terutama ditulis untuk menyesuaikan data melalui LSTM untuk memprediksi harga Bitcoin di masa depan.

import library yang ingin digunakan

import pandas as pd
import numpy as np

from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout

from matplotlib import pyplot as plt
%matplotlib inline

Analisis data

Pemuatan data

Membaca data perdagangan harian BTC

data = pd.read_csv(filepath_or_buffer="btc_data_day")

Untuk melihat data yang tersedia, total data saat ini adalah 1380 data, yang terdiri dari beberapa kolom yaitu Date, Open, High, Low, Close, Volume (BTC), Volume (Currency), dan Weighted Price.

data.info()

Lihat data di 10 baris pertama

data.head(10)

Visualisasi data

Menggunakan matplotlib untuk memetakan harga tertimbang untuk melihat distribusi dan tren data. Dalam gambar, kita menemukan bagian dari data 0 dan kita perlu memastikan apakah data di bawahnya tidak normal.

plt.plot(data['Weighted Price'], label='Price')
plt.ylabel('Price')
plt.legend()
plt.show()

Pengolahan data yang luar biasa

Pertama kita lihat apakah data tersebut mengandung data nan, dan kita bisa melihat bahwa data kita tidak mengandung data nan.

data.isnull().sum()

Date                 0
Open                 0
High                 0
Low                  0
Close                0
Volume (BTC)         0
Volume (Currency)    0
Weighted Price       0
dtype: int64

Jika kita melihat data 0 lagi, kita bisa melihat bahwa ada nilai 0 dalam data kita, dan kita perlu memprosesnya.

(data == 0).astype(int).any()

Date                 False
Open                  True
High                  True
Low                   True
Close                 True
Volume (BTC)          True
Volume (Currency)     True
Weighted Price        True
dtype: bool

data['Weighted Price'].replace(0, np.nan, inplace=True)
data['Weighted Price'].fillna(method='ffill', inplace=True)
data['Open'].replace(0, np.nan, inplace=True)
data['Open'].fillna(method='ffill', inplace=True)
data['High'].replace(0, np.nan, inplace=True)
data['High'].fillna(method='ffill', inplace=True)
data['Low'].replace(0, np.nan, inplace=True)
data['Low'].fillna(method='ffill', inplace=True)
data['Close'].replace(0, np.nan, inplace=True)
data['Close'].fillna(method='ffill', inplace=True)
data['Volume (BTC)'].replace(0, np.nan, inplace=True)
data['Volume (BTC)'].fillna(method='ffill', inplace=True)
data['Volume (Currency)'].replace(0, np.nan, inplace=True)
data['Volume (Currency)'].fillna(method='ffill', inplace=True)

(data == 0).astype(int).any()

Date                 False
Open                 False
High                 False
Low                  False
Close                False
Volume (BTC)         False
Volume (Currency)    False
Weighted Price       False
dtype: bool

Sekarang lihatlah distribusi data dan gerakannya, dan pada saat ini kurva sudah sangat kontinu.

plt.plot(data['Weighted Price'], label='Price')
plt.ylabel('Price')
plt.legend()
plt.show()

Pembagian dataset pelatihan dan dataset uji

Mengintegrasikan data ke 0 - 1

data_set = data.drop('Date', axis=1).values
data_set = data_set.astype('float32')
mms = MinMaxScaler(feature_range=(0, 1))
data_set = mms.fit_transform(data_set)

Pembagian 2:8 antara test dan training data set

ratio = 0.8
train_size = int(len(data_set) * ratio)
test_size = len(data_set) - train_size
train, test = data_set[0:train_size,:], data_set[train_size:len(data_set),:]

Buatlah training dan test datasets, dan gunakan waktu 1 hari sebagai jendela untuk membuat training dan test datasets kita.

def create_dataset(data):
    window = 1
    label_index = 6
    x, y = [], []
    for i in range(len(data) - window):
        x.append(data[i:(i + window), :])
        y.append(data[i + window, label_index])
    return np.array(x), np.array(y)

train_x, train_y = create_dataset(train)
test_x, test_y = create_dataset(test)

Mendefinisikan dan melatih model

Kali ini kita menggunakan model sederhana yang memiliki struktur seperti 1. LSTM2. Dense.

Dalam bentuk input, ukuran input adalah batch_size, time steps, features. Di sini, nilai time steps adalah interval jendela waktu saat data dimasukkan, di sini kita menggunakan 1 hari sebagai jendela waktu, dan data kita adalah data hari, jadi di sini langkah waktu kita adalah 1.

Long short-term memory (LSTM) adalah jenis RNN khusus yang terutama digunakan untuk memecahkan masalah hilangnya gradien dan ledakan gradien selama latihan berurutan panjang.

Dari diagram struktur jaringan LSTM, Anda dapat melihat bahwa LSTM sebenarnya adalah model kecil yang berisi 3 fungsi aktivasi sigmoid, 2 fungsi aktivasi tanh, 3 perkalian, dan satu penjumlahan.

Kondisi Sel

Status sel adalah inti dari LSTM, dia adalah garis hitam di bagian atas gambar di atas, di bawah garis hitam ini ada beberapa pintu, yang akan kita jelaskan di kemudian hari. Status sel akan diperbarui berdasarkan hasil dari setiap pintu. Di bawah ini kita akan menjelaskan pintu-pintu ini, dan Anda akan memahami proses status sel.

Jaringan LSTM dapat menghapus atau menambahkan informasi tentang keadaan sel melalui struktur yang disebut pintu. Pintu dapat secara selektif memutuskan informasi mana yang akan dilewati. Pintu memiliki struktur yang terdiri dari kombinasi dari lapisan sigmoid dan operasi penggandaan titik. Karena output lapisan sigmoid adalah 0-1, 0 berarti tidak dapat dilewati, dan 1 berarti dapat dilewati.

Pintu yang Terlupakan

Langkah pertama dari LSTM adalah menentukan informasi apa yang harus dibuang oleh sel-sel. Bagian dari operasi ini diproses oleh unit sigmoid yang disebut pintu lupa.

Kita dapat melihat bahwa pintu lupa menghasilkan vektor antara 0-1 dengan melihat informasi $h_{l-1}$ dan $x_{t}$, dengan nilai 0-1 dalam vektor yang menunjukkan berapa banyak informasi yang disimpan atau dibuang dalam kondisi sel $C_{t-1}$.

Ekspresi matematika: $f_{t}=\sigma\left ((W_{f} \cdot\left[h_{t-1}, x_{t}\right]+b_{f}\right) $

Pintu masuk

Langkah selanjutnya adalah memutuskan informasi baru apa yang akan ditambahkan ke dalam status sel, yang dilakukan dengan membuka pintu masuk.

Kita melihat bahwa informasi $h_{l-1}$ dan $x_{t}$ dimasukkan ke dalam pintu lupa (sigmoid) dan pintu masuk (tanh). Karena output pintu lupa adalah nilai 0-1, maka jika output pintu lupa adalah 0, maka hasil $C_{i}$ setelah masuk tidak akan ditambahkan ke dalam keadaan sel saat ini, jika 1, maka semuanya akan ditambahkan ke dalam keadaan sel, jadi fungsi pintu lupa di sini adalah untuk menambahkan hasil pintu masuk secara selektif ke dalam keadaan sel.

Rumus matematisnya adalah: $C_{t}=f_{t} * C_{t-1} + i_{t} * \tilde{C}_{t}$

Pintu keluar

Setelah pembaruan keadaan sel diperlukan untuk menentukan karakteristik keadaan sel yang akan diekspor berdasarkan jumlah input $h_{l-1}$ dan $x_{t}$, di mana input harus melewati lapisan sigmoid yang disebut pintu keluar untuk mendapatkan kondisi yang diekspor, dan kemudian keadaan sel melalui lapisan tanh untuk mendapatkan vektor dengan nilai antara -1 hingga 1, yang dikalikan dengan kondisi yang diekspor untuk mendapatkan hasil yang diekspor dari unit RNN akhir, gambar animasi sebagai berikut.

def create_model():
    model = Sequential()
    model.add(LSTM(50, input_shape=(train_x.shape[1], train_x.shape[2])))
    model.add(Dense(1))
    model.compile(loss='mae', optimizer='adam')
    model.summary()
    return model

model = create_model()

history = model.fit(train_x, train_y, epochs=80, batch_size=64, validation_data=(test_x, test_y), verbose=1, shuffle=False)

plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()

train_x, train_y = create_dataset(train)
test_x, test_y = create_dataset(test)

Prediksi

predict = model.predict(test_x)
plt.plot(predict, label='predict')
plt.plot(test_y, label='ground true')
plt.legend()
plt.show()

Saat ini sangat sulit untuk memprediksi pergerakan harga Bitcoin dalam jangka panjang menggunakan pembelajaran mesin, dan artikel ini hanya dapat digunakan sebagai studi kasus. Kasus ini kemudian akan online dan di dalam gambar demo dari Matrix Cloud, yang dapat langsung dialami oleh pengguna yang tertarik.