[PYTHON] [Maschinelles Lernen] FX-Vorhersage unter Verwendung des Entscheidungsbaums

Maschinelles Lernen und FX

Hallo. Dies ist mein erstes Mal, dass ich einen anständigen Artikel über Qiita poste. Vor kurzem habe ich angefangen, maschinelles Lernen zu studieren. Natürlich wird maschinelles Lernen an vielen Orten eingesetzt. Filtern von Spam-E-Mails, Produktempfehlungen usw. Es gibt endlose Beispiele. Trotzdem war ich heute daran interessiert, Aktienkurse und Wechselkurse mithilfe von maschinellem Lernen vorherzusagen Ich möchte FX anhand des __decision-Baums vorhersagen, bei dem es sich um maschinelles Lernen handelt. Wenn Sie Aktienkurse und Wechselkurse mit guter Genauigkeit vorhersagen können, können Sie Geld verdienen, ohne etwas zu tun. Es ist also eine sehr verträumte Geschichte. In Wirklichkeit ist es jedoch nicht so süß, dass es leicht vorhergesagt werden kann. Die Hauptmotivation besteht darin, das maschinelle Lernen, das ich kürzlich studiert habe, auf etwas anzuwenden, anstatt zu gewinnen oder Gewinn zu machen. Wenn Sie also diesen Artikel lesen __ "Ich interessiere mich nicht für maschinelles Lernen, also sagen Sie FX mit AI voraus und sagen Sie mir, ob der Dollar-Yen von morgen steigen oder fallen wird!" __ Es gibt keine nützlichen Informationen für diejenigen, die sagen. Für diejenigen, die sich für maschinelles Lernen und FX-Vorhersage interessieren, kann es ein wenig Spaß machen. Das ist alles.

Was ist FX?

Bei Aktien wissen wir alle, dass Sie einen Gewinn erzielen, wenn Sie Aktien kaufen und der Aktienkurs steigt, und wenn der Aktienkurs fällt, verlieren Sie. Einige Leute wissen vielleicht nichts über FX, deshalb werde ich es vorerst erklären. Angenommen, Sie handeln für 100 Yen pro Dollar. Angenommen, Sie geben in diesem Zustand eine Kaufbestellung im Wert von 1 USD auf. Morgen dieser eine Dollar

• Steigen Sie auf 110 Yen → 10 Yen Gewinn ――Es sinkt auf 90 Yen → Wenn Sie dies tun, verlieren Sie 10 Yen

Korrekt. Diese Art von Börsentransaktion wird als FX bezeichnet. Im Fall von FX können Sie eine Hebelwirkung anwenden. Wenn Sie also die Hebelwirkung mit dem Zehnfachen multiplizieren, können Sie zehnmal mehr Geld bewegen. In diesem Fall beträgt der Gewinn das 10-fache und der Verlust das 10-fache. Seien Sie also vorsichtig. Bei Dollar-Yen-Transaktionen spricht man von Dollar-Yen. Wenn der Wert des Dollars um 100 Yen pro Dollar steigt -> 110 Yen -, wird der Dollar stärker (schwacher Yen), und umgekehrt, wenn der Wert des Dollars um 100 Yen pro Dollar fällt -> 90 Yen, wird der Dollar schwächer (starker Yen). Es wird sein. Ich werde FX nicht mehr erklären, weil es so viele Bücher und Websites gibt, die FX auf leicht verständliche Weise erklären, aber der Punkt ist, dass Sie einen Gewinn erzielen können, wenn Sie vorhersagen können, ob er wie Aktien steigen oder fallen wird __ darüber.

Referenzierte Site

Ich habe auf [hier] verwiesen (http://www.algo-fx-blog.com/decision-tree-classification-fx/). Eine ausführliche Erläuterung des Entscheidungsbaums finden Sie hier. Daher werde ich in diesem Artikel nicht näher darauf eingehen. Kurz gesagt, der Entscheidungsbaum erfordert nicht die Skalierung von Merkmalsgrößen, die als Standardisierung bezeichnet werden, und es ist einfach, den Prozess zu interpretieren, in dem das Ergebnis erhalten wurde (dh Interpretierbarkeit). es gibt. Hier ist eine kurze Zusammenfassung dessen, was auf der verlinkten Seite passiert.

--Vorhersagen, ob der morgige Dollar-Yen ab 2018 steigen oder fallen wird, anhand der täglichen Dollar-Yen-Daten für 500 Tage --Verwenden Sie den Entscheidungsbaum

• Ich benutze keinen anderen Klassifikator. Wir führen keine Rastersuche oder Kreuzungsüberprüfung durch ――Ich habe den Dollar-Yen "Open Price", "Close Price", "High Price" und "Low Price" verwendet.
• Trainingsdaten (Lerndaten) und Testdaten werden im Verhältnis 8: 2 aufgeteilt.
• Als Ergebnis der Anwendung auf Testdaten betrug die Genauigkeitsrate etwa 50%. (Ich kann es nicht sehr gut vorhersagen)

Es ist wie es ist. Die Vorhersagegenauigkeit ist nicht so hoch, da der Hauptzweck darin besteht, die Anwendung von maschinellem Lernen (Entscheidungsbaum) auf FX einzuführen, anstatt ernsthafte Vorhersagen zu treffen.

Was Sie auf dieser Seite tun möchten

• Wenden Sie dieselbe Methode wie auf der oben in Ihrer Umgebung eingeführten Seite an --Verwenden Sie die neuesten täglichen Daten bis Ende 2019 ――Ich möchte herausfinden, wie viele Tage Daten zur Verbesserung der Genauigkeit verwendet werden können (500 Tage? 200 Tage?). ――Ich möchte sehen, ob das Erhöhen der Identität die Genauigkeit verbessert
• Ich möchte die optimalen Parameter des Entscheidungsbaums mithilfe der Rastersuche finden
• Führen Sie die Kreuzüberprüfung ordnungsgemäß durch

Es ist so ein Ort. In Bezug auf die Erhöhung der Merkmale haben wir auf der obigen Seite Daten im Wert von Hunderten von Tagen gelernt, aber wir verwenden den "offenen Preis", den "geschlossenen Preis", den "hohen Preis" und den "niedrigen Preis" als Merkmale, wenn wir tatsächlich Vorhersagen treffen. Es gibt nur vier von ihnen. Mit anderen Worten, wenn entschieden wird, ob der morgige Dollar-Yen steigen oder fallen wird, entscheidet dies nur der Kerzenhalter des "Tages". Wenn Händler jedoch tatsächlich Entscheidungen treffen, verwenden sie häufig verschiedene technische Indikatoren wie gleitende Durchschnitte (Durchschnittswerte für die letzten n Tage), Bollinger-Bänder und MACDs. Also, diesmal, zusätzlich zu den oben genannten vier Eigenschaften, __ "Durchschnitt und Varianz der Schlusskurse an 5, 25, 50 und 75 Tagen" , __ "Eröffnungs-, Schluss- und Hochpreise bis zu den letzten 3 Tagen" , Niedriger Preis " usw. Ich möchte neue hinzufügen. Diese Werte beziehen sich auf die zuvor genannten technischen Indikatoren. Nicht sicher, wovon du sprichst? Bei der Vorhersage des morgigen Dollar-Yen ist es besser, sich nicht nur auf die heutigen Preisbewegungen zu beziehen, sondern auch auf die Durchschnittswerte der letzten Tage bis Wochen und wie stark sie geschwankt haben, oder? Das ist. Um es in eine sehr verwirrende Analogie zu bringen "Der heutige Reis war Curry-Reis, der von meiner Mutter hergestellt wurde. Nach früheren Trends ist der Reis am nächsten Tag nach dem Curry-Reis wahrscheinlich ein Hamburger, also wird morgen ein Hamburger sein!" Ist die Methode, die wir oben machen. Was ich machen will; was ich vorhabe zu tun "Der heutige Reis war Curry und Reis. Gestern war Fleisch, aber letzte Woche gab es viel chinesisches Essen. Ich denke aus der heutigen Speisekarte und den Trends der letzten Wochen ... morgen ist Hamburger!" Ich fühle mich wie. Es ist schwer zu verstehen.

Versuchen Sie mit jupyter zu implementieren

Vorbereitung

Genau wie auf der obigen Seite verwendet Jupyter Python zum Kritzeln. Die Seite ist fast die gleiche wie die oben eingeführte Seite, aber ich werde es in der richtigen Reihenfolge tun. Importieren Sie zunächst verschiedene erforderliche Bibliotheken.

import pandas as pd
import numpy as np 
#Datenvisualisierungsbibliothek
import matplotlib.pyplot as plt
#Bibliothek für maschinelles Lernen
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
#Graphviz importieren
import graphviz
#Für die Rastersuche und Kreuzvalidierung
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV

Die beiden unteren sind erforderlich, wenn Sie eine Rastersuche und eine Kreuzungsüberprüfung durchführen. Laden Sie dann die Daten. Dieses Mal haben wir CSV-Daten für 2 Jahre von 2017 bis 2019 erstellt. Ich handele mit Software namens MT4 und habe die dort bereitgestellten Daten im CSV-Format gebracht.

#CSV-Datei lesen. 2017-2 Jahre 2019
df = pd.read_csv('usd_jpy_api_2017_2019.csv')
#Überprüfen Sie die letzten 5 Zeilen
df.tail()

Die ersten 5 Zeilen sehen so aus. Es repräsentiert die Zeit, den Schlusskurs, den Eröffnungskurs, den hohen Preis, den niedrigen Preis und das Handelsvolumen jeder Transaktion.

Da die Arbeit bis zu diesem Punkt die oben eingeführte Seite ist, werde ich sie grob überspringen, aber ich werde das richtige Antwortetikett mit 0, 1 geben, abhängig davon, ob der Schlusskurs des letzten Tages steigen wird.

#Schlusskurs am nächsten Tag-Berechnen Sie die Differenz zum Schlusskurs des Tages
#shift(-1)Gehen Sie um eins näher heran
df['close+1'] = df.close.shift(-1)
df['diff'] = df['close+1'] - df['close']
#Am letzten Tag schließen+1 wird zu NaN, also schneiden Sie es
df = df[:-1]

Lassen Sie uns das Verhältnis von steigenden und fallenden Daten überprüfen.

#Überprüfen Sie das Datenverhältnis von steigend und fallend
m = len(df['close'])
#df['diff']>0 gibt für alle Zeilen true oder false zurück. df[(df['diff'] > 0)]Mit dff>Geben Sie alle Spalten aus, indem Sie auf 0 eingrenzen
print(len(df[(df['diff'] > 0)]) / m * 100)
print(len(df[(df['diff'] < 0)]) / m * 100)

52.16284987277354
47.837150127226465

Es gibt viele Tage, an denen es leicht gestiegen ist. Entfernen Sie dann die unerwünschten Spalten und benennen Sie das Beschriftungsziel.

• Das Wort "Ziel" entspricht der korrekten Klassenbezeichnung, die zum Lernen erforderlich ist.
• Wenn der Schlusskurs des nächsten Tages steigt, wird 1 zugewiesen, und wenn er fällt, wird 0 zugewiesen.

df.rename(columns={"diff" : "target"}, inplace=True)
#Löschen Sie nicht benötigte Spalten
del df['close+1']
del df['time']
#Spalten sortieren
df = df[['target', 'volume', 'open', 'high', 'low', 'close']]
#Geben Sie die ersten 5 Zeilen aus
df.head()

Hinzufügung der Identität

Von hier aus berechnen wir neue Funktionen und fügen sie hinzu.

#Berechnung des gleitenden Durchschnitts, 5 Tage, 25 Tage, 50 Tage, 75 Tage
#Berechnen Sie auch std. (=Hat die gleichen Informationen wie die Bollinger Band)
#Sichere Daten für 75 Tage
for i in range(1, 75):
    df['close-'+str(i)] = df.close.shift(+i)
#Berechnen Sie den gleitenden Durchschnittswert und std,Wenn sich in der Skipna-Einstellung sogar eine Nan befindet, wird Nan zurückgegeben.
nclose = 5    
df['MA5'] = df.iloc[:, np.arange(nclose, nclose+5)].mean(axis='columns', skipna=False)
df['MA25'] = df.iloc[:, np.arange(nclose, nclose+25)].mean(axis='columns', skipna=False)
df['MA50'] = df.iloc[:, np.arange(nclose, nclose+50)].mean(axis='columns', skipna=False)
df['MA75'] = df.iloc[:, np.arange(nclose, nclose+75)].mean(axis='columns', skipna=False)

df['STD5'] = df.iloc[:, np.arange(nclose, nclose+5)].std(axis='columns', skipna=False)
df['STD25'] = df.iloc[:, np.arange(nclose, nclose+25)].std(axis='columns', skipna=False)
df['STD50'] = df.iloc[:, np.arange(nclose, nclose+50)].std(axis='columns', skipna=False)
df['STD75'] = df.iloc[:, np.arange(nclose, nclose+75)].std(axis='columns', skipna=False)
#Löschen Sie zusätzliche Spalten nach der Berechnung
for i in range(1, 75):
    del df['close-'+str(i)]
#Änderungen gegenüber dem Vortag jeder Durchschnittslinie (Sie können sehen, ob die gleitende Durchschnittslinie nach oben oder unten verläuft)
#shift(-1)Gehen Sie um eins näher heran
df['diff_MA5'] = df['MA5'] - df.MA5.shift(1) 
df['diff_MA25'] = df['MA25'] - df.MA25.shift(1) 
df['diff_MA50'] = df['MA50'] - df.MA50.shift(1) 
df['diff_MA75'] = df['MA50'] - df.MA50.shift(1) 
#Vor bis zu 3 Tagen geöffnet, close, high,Ich möchte meiner Identität etwas hinzufügen
for i in range(1, 4):
    df['close-'+str(i)] = df.close.shift(+i)
    df['open-'+str(i)] = df.open.shift(+i)
    df['high-'+str(i)] = df.high.shift(+i)
    df['low-'+str(i)] = df.low.shift(+i)
#Zeile mit NaN löschen
df = df.dropna()
#Entscheiden Sie, wie viele Tage Sie verwenden möchten
nday = 500
df = df[-nday:]
#df.head()
df

Die rechte Seite ist abgeschnitten, aber es sieht so aus.

• MA ist der gleitende Durchschnitt. Beispielsweise ist MA5 der durchschnittliche Schlusskurs der letzten 5 Tage ab diesem Datum. --close-n repräsentiert den Schlusskurs vor n Tagen (gleich für offen, hoch und niedrig) --STD ist die Standardabweichung ――Ich wollte wissen, ob der gleitende Durchschnitt nach oben oder unten zeigt, deshalb habe ich die Änderung vom Vortag mit dem Namen diff_ hinzugefügt.

Vorerst habe ich Daten für 500 Tage ausgewählt. Es war in Ordnung, dies beim ersten Lesen der Daten anzugeben. Bei der Berechnung des 75-Tage-Durchschnitts sind jedoch Daten erforderlich, die 75 Tage zurückreichen. Daher werden Daten im Wert von 500 Tagen nach Abschluss der Berechnung verwendet. Ich benutze. Sie haben jetzt 500 Zeilen und 30 Datenspalten.

Den Entscheidungsbaum lernen

Jetzt, da wir bereit sind, teilen wir es in Zug und testen und bewerten es.

n = df.shape[0]
p = df.shape[1]
print(n,p)
#Unterteilt in Trainingsdaten und Testdaten. Mische nicht
train_start = 0
train_end = int(np.floor(0.8*n))
test_start = train_end + 1
test_end = n
data_train = np.arange(train_start, train_end)
data_train = df.iloc[np.arange(train_start, train_end), :]
data_test = df.iloc[np.arange(test_start, test_end), :]
#Überprüfen Sie die Größe der Trainingsdaten und Testdaten
print(data_train.shape)
print(data_test.shape)

Diesmal wurde es um 8: 2 aufgeteilt.

(400, 30)
(99, 30)

Als nächstes wird der Teil des richtigen Antwortetiketts getrennt und das Lernen mit dem Entscheidungsbaum durchgeführt. Der Hyperparameter max_depth, der die Tiefe des Baums angibt, wird vorerst auf 5 gesetzt, der entsprechende Wert wird jedoch anschließend durch Rastersuche ermittelt.

#Separates Ziel
X_train = data_train.iloc[:, 1:]
y_train = data_train.iloc[:, 0]
X_test = data_test.iloc[:, 1:]
y_test = data_test.iloc[:, 0]
#Training des entscheidenden Technikmodells
clf_2 = DecisionTreeClassifier(max_depth=5)

Der Entscheidungsbaum ist endlich herausgekommen. Führen Sie eine Kreuzvalidierung und Rastersuche mit k = 10 durch.

#max mit Rastersuche_Bestimmen Sie die optimalen Parameter für die Tiefe
#k=Führen Sie auch eine Überprüfung der 10-k-Teilungskreuzung durch
params = {'max_depth': [2, 5, 10, 20]}

grid = GridSearchCV(estimator=clf_2,
                    param_grid=params,
                    cv=10,
                    scoring='roc_auc')
grid.fit(X_train, y_train)
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
    print("%0.3f +/- %0.2f %r"
          % (grid.cv_results_['mean_test_score'][r],
             grid.cv_results_['std_test_score'][r] / 2.0,
             grid.cv_results_['params'][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)

Die Ausgabe sieht so aus. Wenn die Tiefe 10 beträgt, ist die richtige Antwortrate mit 69% am höchsten.

0.630 +/- 0.05 {'max_depth': 2}
0.679 +/- 0.06 {'max_depth': 5}
0.690 +/- 0.06 {'max_depth': 10}
0.665 +/- 0.05 {'max_depth': 20}
Best parameters: {'max_depth': 10}
Accuracy: 0.69

Auswertung mit Testdaten

Die oben angegebene richtige Antwortrate ist nur die richtige Antwortrate in den Trainingsdaten. Versuchen wir also, die Testdaten vorherzusagen.

#Erfahren Sie, wie Sie die Parameter verwenden, die für die Rastersuche am besten geeignet sind
clf_2 = grid.best_estimator_
clf_2 = clf_2.fit(X_train, y_train)
clf_2

Sie können sehen, dass die Parameter so eingestellt sind.

DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=10,
                       max_features=None, max_leaf_nodes=None,
                       min_impurity_decrease=0.0, min_impurity_split=None,
                       min_samples_leaf=1, min_samples_split=2,
                       min_weight_fraction_leaf=0.0, presort=False,
                       random_state=None, splitter='best')

Lassen Sie es uns visualisieren, weil es eine große Sache ist. Da max_depth = 10 ist, wird es ein Chaos sein. .. Wenn Sie nur den oberen Teil ausschneiden, sieht es so aus. In diesem Fall ist ersichtlich, dass der hohe Preis vor drei Tagen danach geteilt wird, ob er 82.068 oder mehr oder weniger beträgt, und dann wird der Schwellenwert durch den niedrigen Preis des Tages bestimmt und geteilt. Die Tatsache, dass es als Gini gekauft wird, bedeutet, dass die Teilung so durchgeführt wird, dass der Wert der Gini-Reinheit klein wird. Der Wert = Teil gibt an, wie viele steigt und fällt.

Lassen Sie uns die richtige Antwortrate des Tests überprüfen.

pred_test_2 = clf_2.predict(X_test)
#Testdatengenauigkeitsrate
accuracy_score(y_test, pred_test_2)

0.555555555555

Hmm. .. Es fühlt sich an wie ... für all die harte Arbeit, aber es ist so. Mal sehen, welche Features wichtig sind (Feature-Impotanz).

#Zeigen Sie wichtige Eigenschaften an
importances = clf_2.feature_importances_
indices = np.argsort(importances)[::-1]

for f in range(X_train.shape[1]):
    print("%2d) %-*s %f" % (f + 1, 30, 
                            df.columns[1+indices[f]],
                            importances[indices[f]]))    

Ich habe versucht, den gleitenden Durchschnitt zu berechnen und so weiter, aber am Ende scheint es, dass die Preisbewegung am Tag oder am Tag zuvor wichtig ist.

 1) low                            0.407248
 2) close                          0.184738
 3) low-1                          0.078743
 4) high-3                         0.069653
 5) high                           0.043982
 6) diff_MA5                       0.039119
 7) close-3                        0.035420
 8) STD50                          0.035032
 9) diff_MA25                      0.029473
10) MA75                           0.028125
11) MA50                           0.009830
12) open-3                         0.009540
13) STD25                          0.009159
14) low-3                          0.007632
15) high-1                         0.007632
16) volume                         0.004674
Da es unten 0 ist, wird es weggelassen

Spielen Sie mit verschiedenen Werten herum

Lassen Sie uns die Bedingungen für diese Überprüfung noch einmal zusammenfassen

--__ Aggregationszeitraum : 500 Tage bis zum 31. Dezember 2019 -- Klassifikator : Entscheidungsbaum -- Parameter _: max_depth = 10 -- Schnittpunktüberprüfung : 10 Unterteilungen -- Trainings- und Testaufteilung : 8: 2 -- Ergebnis __: Richtige Antwortrate 0,55 Hier wurden die Parameter des Entscheidungsbaums durch Rastersuche festgelegt, daher fand ich es in Ordnung, aber ich habe es versucht, weil die Aggregationsperiode und das Teilungsverhältnis manipuliert zu sein schienen.

--_ Das Ergebnis der Änderung des Teilungsverhältnisses auf 9: __ → Richtige Antwortrate: __ 61% __ (max_depth = 20) --__ Ergebnis einer Gesamtdauer von 200 Tagen __ → Richtige Antwortrate: __ 56% __ (max_depth = 10) ist geworden. Die richtige Antwortrate liegt bei 50-60%. Die Rastersuche wird jedes Mal wiederholt, wenn die Bedingungen geändert werden, aber ungefähr max_depth = 10-20 war die beste Punktzahl.

Was ich diesmal gelernt habe

――Wenn Sie Ihr Bestes tun, um Vorhersagen auf der Grundlage der täglichen Daten des Dollar-Yen zu treffen, erhalten Sie eine Genauigkeit von etwa 50-60%.

Was ich in Zukunft machen möchte

• Versuchen Sie es mit einem anderen Klassifikator als dem Entscheidungsbaum (logistische Regression, kNN usw.).
• Verwenden Sie die Ensemble-Methode (kombinieren Sie mehrere Klassifikatoren)
• Führen Sie eine angemessene Dimensionsreduzierung durch (diesmal war dies aufgrund der Art des Entscheidungsbaums nicht erforderlich).
• Über die Natur nachdenken (vielleicht gibt es eine bessere Menge an Funktionen ... ??)

Es ist länger als ich erwartet hatte. .. Ende