[PYTHON] Probieren Sie die Bitcoin-Preisprognose mit Deep Learning aus
Kostenloses Studium der Sommerferien ~ Traum vom Arbeitsloseneinkommen ~
Ich habe ein Zertifikat bei Coursera erworben, damit ich meine Sommerferien damit verbringen kann, etwas mit maschinellem Lernen oder Deep Learning zu machen. Es gibt großartige Menschen auf der Welt, und es gibt einen Ansatz, der bereits so weit ausprobiert wurde, dass ich es satt habe, und ich werde es mit der Denkkraft versuchen, die ich studiert habe.
In Zukunft möchte ich ein sehr genaues Modell erstellen, ein Traumarbeitsloseneinkommen erzielen und Steuern zahlen.
Einführung
Ich habe einen Tag gebraucht, um zu lernen.
Umgebung
So installieren Sie TensorFlow, das selbst Anfänger des maschinellen Lernens sofort ausführen können Viele Leute machen es bereits, also ahmen Sie es bitte nach. Die Sache, bei der Sie vorsichtig sein müssen, ist, es mit Python3 zu tun. Es ist gut, die Version anzugeben, die mit pyenv usw. verwendet werden soll.
Ich denke, es kann in ungefähr 10 Minuten erledigt werden.
Bibliothek
Keras ist eine in Python geschriebene übergeordnete neuronale Netzwerkbibliothek, die auf TensorFlow, CNTK oder Theano ausgeführt werden kann.
Ich habe mich gefragt, ob Deep Learning TensorFlow haben sollte, aber natürlich gibt es viele Frameworks, die es umschließen, und Keras ist eines davon. Sie können theano/tensorflow wie in der Dokumentation beschrieben verwenden.
Schließlich sind beide für den Umgang mit Tensoren gedacht, und ich verstehe den Unterschied nicht wirklich, aber zuerst dachte ich, dass es nicht so wichtig ist, und übersprang ihn.
numpy Praktischer Typ für die numerische Berechnung von Python
pandas Ein praktischer Typ, der mit Zeitreihendaten umgeht
data = pandas.read_csv('./csv/bitcoin_log_1month.csv')
data = data.sort_values(by='date')
data = data.reset_index(drop=True)
Es ist bequem, csv so zu laden. Zusätzlich zum Laden kann es sortiert und indiziert werden.
Scikit-learn Es bietet ein praktisches Modul für maschinelles Lernen. Da es für die Verarbeitung von numpy.ndarray vorausgesetzt wird, wird es dafür ausgeführt. Es gibt auch ein Normalisierungsmodul.
tflearn Es ist eine Bibliothek, mit der Sie TensorFlow wie Scikit-learn verwenden können. In TensorFlow integriert, baut es neuronale Netze auf und definiert Modelle.
matplotlib Jeder liebt Matlab. Es wird verwendet, um das erstellte Diagramm zu visualisieren und als Bild zu speichern. Da beim Importieren ein Fehler auftritt, ändern Sie matplotlibrc teilweise unter Bezugnahme auf den folgenden Link.
Design
Was soll ich zuerst tun? Werfen wir einen Blick auf viele hilfreiche Links. Schließlich möchte ich etwas machen, das die binäre Klassifizierung "ob der Schlusskurs von morgen steigen oder fallen wird" lösen kann. Durch das Aufrufen eines Referenzlinks konnte ich den Wunsch vermitteln, für alle ein Arbeitsloseneinkommen zu generieren. Oh ja.
Referenz
- TensorFlow (LSTM) Aktienprognose ~ Aktienprognose Teil 1 ~
- RNN prognostiziert die Passagierzahlen der Fluggesellschaft im nächsten Monat: TFLearn implementiert von LSTM zu GRU
- Versuchen Sie, den Wechselkurs (FX) mit TensorFlow (Deep Learning) vorherzusagen
Lass uns verstehen
Immerhin sind ML und DL sehr unterschiedlich, was also gehandhabt wird, ist sehr unterschiedlich, also habe ich es organisiert.
Erforderlicher Durchfluss
1. Sicherung von Zeitreihendaten
Es gibt verschiedene Stellen, an denen die Zeitreihendaten von Bitcoin über die API abgerufen werden können, aber ich wollte es investieren. ) Zu DL. Sie können den jährlichen Schlusskurs für mehrere Jahre nehmen. Wenn es nicht JPY ist, gibt es viele andere Optionen.
2. Dataset-Formatierung
Wir werden die notwendigen Daten normalisieren und standardisieren. Zu diesem Zeitpunkt ist es in sklearn [Verarbeitungspaket](http://qiita.com/nazoking@github/items/d6ac1948ee138d73fef1#431-%E6%A8%99%E6%BA%96%E5%8C%96%E5%B9%B3%E5% 9D% 87% E9% 99% A4% E5% 8E% BB% E3% 81% A8% E5% 88% 86% E6% 95% A3% E3% 81% AE% E3% 82% B9% E3% 82% Mit B1% E3% 83% BC% E3% 83% AA% E3% 83% B3% E3% 82% B0) können Sie ganz einfach Folgendes tun:
data['close'] = preprocessing.scale(data['close'])
3. Auswahl des zu verwendenden Modells und Fehlers
Der erforderliche Fehler und das Modell unterscheiden sich je nach den verwendeten Daten. Selbst wenn Sie hier nicht viel wissen, können Sie dies überprüfen, indem Sie die Argumente ersetzen. Ich denke, man kann wirklich richtig lernen und aussagekräftige Ergebnisse erzielen.
Prinzip des einfachen tiefen Lernens
LSTM (Long Short-Term Memory) ist ein leistungsstarkes Modell, das die Nachteile von RNN beseitigt und langfristige Zeitreihendaten lernen kann.
Es gibt verschiedene Modelle wie GRU und LSTN, und ich werde die Funktionen nicht erwähnen, aber es gibt verschiedene.
Der Rest ist ein Fehler
Bedeutung verschiedener Fehler (RMSE, MAE usw.) Es gibt verschiedene Typen wie MAPE und RMSE. Da es sich um einen Bewertungsindex handelt, wird bewertet, wie weit der gemessene Wert und der vorhergesagte Wert sind, wenn das Modell geändert oder die Datenmenge hinzugefügt wird.
4. Vorbereitung von Trainingsdaten und Testdaten
Wählen Sie aus, wie viele Daten Sie lernen möchten, und vergleichen Sie sie mit den von Ihnen vorbereiteten Daten. Training: Ich hatte das Gefühl, dass ich oft Test = 8: 2 gesetzt habe.
5. Vorhersage basierend auf diesen
Erstellen Sie ein Modell unter Verwendung des aufgebauten neuronalen Netzwerks, führen Sie darauf basierend eine Anpassung durch und führen Sie eine Vorhersage durch.
6. Bewertung
Danach werden die Ergebnisse grafisch dargestellt, visualisiert und ausgewertet. Mit TensorBoard können Sie Modelle und Fehler einfach visualisieren.
Ich habe aus den Referenzen gelernt, dass ich diesen Ablauf grob umsetzen kann.
Implementierung
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tflearn
from sklearn import preprocessing
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.layers.recurrent import LSTM
class Prediction :
def __init__(self):
self.dataset = None
#Zu berechnende Werte
self.model = None
self.train_predict = None
self.test_predict = None
#Einstellungen der Datensatzparameter
self.steps_of_history = 3
self.steps_in_future = 1
self.csv_path = './csv/bitcoin_log.csv'
def load_dataset(self):
#Datenaufbereitung
dataframe = pd.read_csv(self.csv_path,
usecols=['Schlusskurs'],
engine='python').sort_values('Schlusskurs', ascending=True)
self.dataset = dataframe.values
self.dataset = self.dataset.astype('float32')
#Standardisierung
self.dataset -= np.min(np.abs(self.dataset))
self.dataset /= np.max(np.abs(self.dataset))
def create_dataset(self):
X, Y = [], []
for i in range(0, len(self.dataset) - self.steps_of_history, self.steps_in_future):
X.append(self.dataset[i:i + self.steps_of_history])
Y.append(self.dataset[i + self.steps_of_history])
X = np.reshape(np.array(X), [-1, self.steps_of_history, 1])
Y = np.reshape(np.array(Y), [-1, 1])
return X, Y
def setup(self):
self.load_dataset()
X, Y = self.create_dataset()
# Build neural network
net = tflearn.input_data(shape=[None, self.steps_of_history, 1])
#LSTM braucht Zeit, also GRU
# http://dhero.hatenablog.com/entry/2016/12/02/%E6%9C%80%E5%BC%B1SE%E3%81%A7%E3%82%82%E6%A9%9F%E6%A2%B0%E5%AD%A6%E7%BF%92%E3%81%A7%E3%81%8A%E9%87%91%E3%81%8C%E7%A8%BC%E3%81%8E%E3%81%9F%E3%81%84%E3%80%905%E6%97%A5%E7%9B%AE%E3%83%BBTFLearn%E3%81%A8
net = tflearn.gru(net, n_units=6)
net = tflearn.fully_connected(net, 1, activation='linear')
#Regressionseinstellungen
#Gemessen nach der Adam-Methode
# http://qiita.com/TomokIshii/items/f355d8e87d23ee8e0c7a
#Mittelwert als Index der Vorhersagegenauigkeit bei der Zeitreihenanalyse_Ich benutze Quadrat
#Mape scheint üblich zu sein
# categorical_crossentropy
# mean_square :Quadratische mittlere Quadratwurzel
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='mean_square')
# Define model
self.model = tflearn.DNN(net, tensorboard_verbose=0)
#Diesmal 80%Der Trainingsdatensatz, 20%Wird als Testdatensatz behandelt.
pos = round(len(X) * (1 - 0.2))
trainX, trainY = X[:pos], Y[:pos]
testX, testY = X[pos:], Y[pos:]
return trainX, trainY, testX
def executePredict(self, trainX, trainY, testX):
# Start training (apply gradient descent algorithm)
self.model.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=1, n_epoch=150, run_id='btc')
# predict
self.train_predict = self.model.predict(trainX)
self.test_predict = self.model.predict(testX)
def showResult(self):
# plot train data
train_predict_plot = np.empty_like(self.dataset)
train_predict_plot[:, :] = np.nan
train_predict_plot[self.steps_of_history:len(self.train_predict) + self.steps_of_history, :] = \
self.train_predict
# plot test dat
test_predict_plot = np.empty_like(self.dataset)
test_predict_plot[:, :] = np.nan
test_predict_plot[len(self.train_predict) + self.steps_of_history:len(self.dataset), :] = \
self.test_predict
# plot show res
plt.figure(figsize=(8, 8))
plt.title('History={} Future={}'.format(self.steps_of_history, self.steps_in_future))
plt.plot(self.dataset, label="actual", color="k")
plt.plot(train_predict_plot, label="train", color="r")
plt.plot(test_predict_plot, label="test", color="b")
plt.savefig('result.png')
plt.show()
if __name__ == "__main__":
prediction = Prediction()
trainX, trainY, testX = prediction.setup()
prediction.executePredict(trainX, trainY, testX)
prediction.showResult()
Ich habe auf die Site verwiesen, auf die ich sehr viel verwiesen habe, aber die Implementierung und das Verständnis haben ungefähr eine Stunde gedauert.
Geben Sie kurz die Codebeschreibung ein.
load_dataset
Die diesmal verwendeten Daten sind wie folgt. Lesen Sie dies und verwenden Sie es als Datensatz. Da die Reihenfolge der Daten umgekehrt ist, sortieren Sie usw.
"Datum","Schlusskurs","Offener Preis","Hoher Preis","Niedriger Preis","Verhältnis des vorherigen Tages"
"03. September 2017","523714.1875","499204.7813","585203.1250","499204.7813","4.91"
"02. September 2017","499204.7813","542277.3125","585203.1250","498504.5000","-7.94"
setup Bauen Sie ein neuronales Netzwerk auf. GRU ist eine der DL-Methoden. Es gibt verschiedene Dinge wie LSTM und RNN, aber dieses Mal habe ich es mit einem Schwerpunkt auf Geschwindigkeit gewählt.
net = tflearn.input_data(shape=[None, self.steps_of_history, 1])
net = tflearn.gru(net, n_units=6)
net = tflearn.fully_connected(net, 1, activation='linear')
Auswahl der Optimierungsmethode / Fehleinschätzung Diesmal lautet die Optimierung Adam-Methode und der Fehler ist mean_square (RMSE (Root Mean Square Error)). / rmsemae) wird verwendet. Da Methoden wie MAPE nicht standardmäßig vorbereitet sind, scheint es notwendig zu sein, die Bibliothek teilweise neu zu schreiben, damit sie verwendet werden kann.
net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
loss='mean_square')
executePredict
Trainings- / Testdaten auswählen und vorhersagen.
#Diesmal 80%Der Trainingsdatensatz, 20%Wird als Testdatensatz behandelt.
pos = round(len(X) * (1 - 0.2))
trainX, trainY = X[:pos], Y[:pos]
testX, testY = X[pos:], Y[pos:]
# Start training (apply gradient descent algorithm)
self.model.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=1, n_epoch=150, run_id='btc')
# predict
self.train_predict = self.model.predict(trainX)
self.test_predict = self.model.predict(testX)
Siehe das Ergebnis
Schwarz sind die tatsächlichen Daten, Rot sind die Trainingsdaten und Blau ist der vorhergesagte Wert basierend auf den Testdaten.
Hier ist das Ergebnis von TensorBoard.
Es ist wie bei Humuu. Verlust / Validierung ist vorerst seltsam. Von hier aus werden wir unser Bestes tun, um Parameter zu untersuchen, die Fehler reduzieren können, während die Anzahl der Epochen, Modelle und Schritte, das Trainingsdatenverhältnis und die Datenmenge, die Anzahl der GRU-Schichten usw. geändert werden.
Übrigens habe ich versucht, die Verwendung von LSTM mit sklearn ohne Verwendung von tflearn wie folgt vorherzusagen.
model.add(LSTM(self.hidden_neurons, \
batch_input_shape=(None, self.length_of_sequences, self.in_out_neurons), \
return_sequences=False))
model.add(Dense(self.in_out_neurons))
model.add(Activation("linear"))
model.compile(loss="mape", optimizer="adam")
mape ist nicht in tflearn, aber ist es in sklearn ...? ?? Sehr schwierig.
Zusammenfassung
Ich habe etwas gemacht, das vorerst funktioniert, aber die Sommerferien sind vorbei und der Rest wird zu einem späteren Zeitpunkt erledigt. Jetzt, da ich es verschieben kann, werde ich mehr über die Überprüfungsmethode erfahren und die Genauigkeit verbessern.
nach
Visual Studio Code für Mac war sehr gut. Ich dachte, die Python-Implementierung sei Pychams Wahl, aber sie ist sehr gut.
Recommended Posts