Maschinelles Lernen: Vorhersage der Aktienkurse an der Börse

Die Übersetzerin Polina Kabirova hat speziell für Netologia einen Artikel des Ingenieurs der Universität Cambridge, Vivek Palaniappan, über die Erstellung eines Modells unter Verwendung neuronaler Netze angepasst, mit dem die Aktienkurse an einer Börse vorhergesagt werden können.

Maschinelles und tiefes Lernen ist zu einer neuen wirksamen Strategie geworden, mit der viele Investmentfonds ihre Einnahmen steigern. In dem Artikel werde ich erklären, wie neuronale Netze helfen, die Situation an der Börse vorherzusagen - zum Beispiel den Aktienkurs (oder den Index). Der Text basiert auf meinem in Python geschriebenen Projekt . Den vollständigen Code und die Programmanleitung finden Sie auf GitHub. Lesen Sie andere verwandte Artikel im Medium Blog.

Neuronale Netze in der Wirtschaft

Änderungen im Finanzbereich sind nicht linear, und manchmal scheint es, dass die Aktienkurse völlig zufällig gebildet werden. Herkömmliche Zeitreihenmethoden wie die Modelle ARIMA und GARCH sind wirksam, wenn die Reihe stationär ist - ihre grundlegenden Eigenschaften ändern sich im Laufe der Zeit nicht. Dies setzt voraus, dass die Serie mithilfe von log returns vorverarbeitet oder anders stationärisiert wurde. Das Hauptproblem tritt jedoch auf, wenn diese Modelle in einem realen Handelssystem implementiert werden, da die Stationarität beim Hinzufügen neuer Daten nicht garantiert wird.

Die Lösung für dieses Problem können neuronale Netze sein, die keine Stationarität erfordern. Neuronale Netze sind anfangs sehr effektiv beim Auffinden von Beziehungen zwischen Daten und können neue Daten basierend auf diesen vorhersagen (oder klassifizieren).

In der Regel besteht ein Data Science-Projekt aus folgenden Operationen:

1. Datenerfassung - bietet eine Reihe notwendiger Eigenschaften.
2. Die Datenvorverarbeitung ist oft ein beängstigender, aber notwendiger Schritt, bevor die Daten verwendet werden.
3. Die Entwicklung und Implementierung des Modells hängt von der Art des neuronalen Netzwerks und seinen Parametern ab.
4. Backtesting-Modelle (Testen historischer Daten) sind ein wichtiger Schritt in jeder Handelsstrategie.
5. Optimierung - Suche nach geeigneten Parametern.

Eingabe für unser neuronales Netzwerk - Daten zu Aktienkursen der letzten 10 Tage. Mit ihrer Hilfe werden wir die Preise am nächsten Tag vorhersagen.

Datenerfassung

Glücklicherweise finden Sie die für dieses Projekt benötigten Daten auf Yahoo Finance. Daten können mithilfe der Python-API pdr.get_yahoo_data(ticker, start_date, end_date) oder direkt von der Site pdr.get_yahoo_data(ticker, start_date, end_date) werden.

Datenvorverarbeitung

In unserem Fall müssen die Daten in Trainingssätze unterteilt werden, die aus 10 vergangenen Preisen und Preisen für den nächsten Tag bestehen. Zu diesem Preprocessing ich die Preprocessing definiert, die mit Trainings- und Testdaten arbeitet. Innerhalb der Klasse habe ich die get_train(self, seq_len) , die Trainingseingabe- und -ausgabedaten in NumPy Arrays konvertiert und eine bestimmte Fensterlänge get_train(self, seq_len) (in unserem Fall 10). Der gesamte Code sieht folgendermaßen aus:

 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) 

Ebenso habe ich eine Methode definiert, die die Testdaten X_test und Y_test .

Neuronale Netzwerkmodelle

Für das Projekt habe ich zwei Modelle neuronaler Netze verwendet: das Multilayer Perceptron (MLP) und das Long Short Term Model (LSTM). Ich werde kurz darauf eingehen, wie diese Modelle funktionieren. Lesen Sie mehr über MLP in einem anderen Artikel und über die Arbeit von LSTM in Jacob Aungiers.

MLP ist die einfachste Form neuronaler Netze. Eingabedaten fallen in das Modell und unter Verwendung bestimmter Gewichte werden die Werte durch verborgene Schichten übertragen, um Ausgabedaten zu erhalten. Das Erlernen des Algorithmus erfolgt durch Rückausbreitung durch verborgene Schichten, um die Gewichtswerte jedes Neurons zu ändern. Das Problem bei diesem Modell ist der Mangel an "Speicher". Es ist unmöglich zu bestimmen, was die vorherigen Daten waren und wie sie sich auf die neuen auswirken können und sollten. Im Kontext unseres Modells können 10-Tage-Unterschiede zwischen den Daten zweier Datensätze von Bedeutung sein, aber MLPs können solche Beziehungen nicht analysieren.

Verwenden Sie dazu LSTM oder Recurrent Neural Networks (RNN). RNNs speichern bestimmte Dateninformationen zur späteren Verwendung. Dies hilft dem neuronalen Netzwerk, die komplexe Struktur der Beziehungen zwischen Aktienkursdaten zu analysieren. Bei RNN tritt jedoch das Problem eines Fading-Gradienten auf. Der Gradient nimmt ab, weil die Anzahl der Schichten zunimmt und das Trainingsniveau (ein Wert kleiner als Eins) mehrmals multipliziert wird. Lösen Sie dieses LSTM-Problem, indem Sie die Effizienz steigern.

Modellimplementierung

Um das Modell zu implementieren, habe ich Keras , da dort nach und nach Ebenen hinzugefügt werden und nicht das gesamte Netzwerk auf einmal definiert wird. So können wir die Anzahl und den Typ der Schichten schnell ändern und das neuronale Netzwerk optimieren.

Ein wichtiger Schritt bei der Arbeit mit Aktienkursen ist die Datennormalisierung. Normalerweise subtrahieren Sie dazu den durchschnittlichen Fehler und dividieren durch den Standardfehler. Wir brauchen dieses System jedoch, um für einen bestimmten Zeitraum im realen Handel eingesetzt zu werden. Daher ist die Verwendung von Statistiken möglicherweise nicht der genaueste Weg, um Daten zu normalisieren. Also habe ich einfach alle Daten in 200 geteilt (eine willkürliche Zahl, im Vergleich zu der alle anderen Zahlen klein sind). Und obwohl es den Anschein hat, dass eine solche Normalisierung nicht gerechtfertigt und nicht sinnvoll ist, ist es effektiv sicherzustellen, dass die Gewichte im neuronalen Netzwerk nicht zu groß werden.

Beginnen wir mit einem einfacheren Modell - MLP. Keras erstellt eine Sequenz und fügt dichte Ebenen hinzu. Der vollständige Code sieht folgendermaßen aus:

 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") 

Mit Keras in fünf Codezeilen haben wir MLP mit versteckten Schichten mit jeweils einhundert Neuronen erstellt. Und jetzt ein wenig zum Optimierer. Die Adam-Methode (Adaptive Moment Estimation) wird immer beliebter - ein effizienterer Optimierungsalgorithmus im Vergleich zum stochastischen Gradientenabstieg . Es gibt zwei weitere Erweiterungen des stochastischen Gradientenabstiegs - Adam-Vorteile sind sofort vor ihrem Hintergrund sichtbar:

AdaGrad - behält eine festgelegte Lerngeschwindigkeit bei, die die Ergebnisse verbessert, wenn die Gradienten divergieren (z. B. bei Problemen mit der natürlichen Sprache und der Bildverarbeitung).

RMSProp - behält eine festgelegte Trainingsgeschwindigkeit bei, die abhängig von den Durchschnittswerten der letzten Gewichtsverläufe (z. B. wie schnell sie sich ändern) variieren kann. Dies bedeutet, dass der Algorithmus instationäre Probleme (z. B. Rauschen) gut bewältigt.

Adam kombiniert die Vorteile dieser Erweiterungen, also habe ich mich dafür entschieden.

Jetzt passen wir das Modell an unsere Trainingsdaten an. Keras vereinfacht die Aufgabe erneut, es wird nur der folgende Code benötigt:

 model.fit(X_train, Y_train, epochs=100) 

Wenn das Modell fertig ist, müssen Sie es anhand der Testdaten überprüfen, um festzustellen, wie gut es funktioniert hat. Dies geschieht folgendermaßen:

 model.evaluate(X_test, Y_test) 

Die aus der Überprüfung gewonnenen Informationen können verwendet werden, um die Fähigkeit des Modells zu bewerten, Aktienkurse vorherzusagen.

Ein ähnliches Verfahren wird für das LSTM-Modell verwendet, daher werde ich den Code zeigen und ein wenig erklären:

 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) 

Bitte beachten Sie, dass Keras je nach Modell Daten einer bestimmten Größe benötigt. Es ist sehr wichtig, die Form des Arrays mit NumPy zu ändern.

Backtesting-Modelle

Wenn wir unsere Modelle anhand von Trainingsdaten vorbereitet und anhand von Testdaten getestet haben, können wir das Modell anhand historischer Daten testen. Dies geschieht wie folgt:

 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()}") 

Dies ist jedoch eine vereinfachte Testversion. Für ein vollständiges Backtesting-System sollten Faktoren wie „Survivorship Bias“, Bias (Look Ahead Bias), sich ändernde Marktbedingungen und Transaktionskosten berücksichtigt werden. Da dies nur ein Bildungsprojekt ist, reicht ein einfaches Backtesting aus.


Prognose meines LSTM-Modells für Apple-Aktienkurse im Februar

Für ein einfaches LSTM-Modell ohne Optimierung ist dies ein sehr gutes Ergebnis. Es zeigt, dass neuronale Netze und Modelle des maschinellen Lernens komplexe, stabile Verbindungen zwischen Parametern herstellen können.

Hyperparameter-Optimierung

Eine Optimierung ist häufig erforderlich, um die Modellergebnisse nach dem Testen zu verbessern. Ich habe es nicht in die Open Source-Version aufgenommen, damit die Leser versuchen können, das Modell selbst zu optimieren. Diejenigen, die nicht wissen, wie sie optimieren sollen, müssen Hyperparameter finden, die die Leistung des Modells verbessern. Es gibt verschiedene Methoden zum Auffinden von Hyperparametern: von der Auswahl von Parametern in einem Raster bis zu stochastischen Methoden.

Ich bin sicher, dass mit der Optimierung von Modellen das Wissen im Bereich des maschinellen Lernens ein neues Niveau erreicht. Versuchen Sie, das Modell so zu optimieren, dass es besser funktioniert als meins. Vergleichen Sie das Ergebnis mit der obigen Grafik.

Fazit

Das maschinelle Lernen entwickelt sich ständig weiter - jeden Tag tauchen neue Methoden auf, daher ist es sehr wichtig, ständig zu lernen. Der beste Weg, dies zu tun, besteht darin, interessante Projekte zu erstellen, beispielsweise Modelle für die Prognose von Aktienkursen zu erstellen. Und obwohl mein LSTM-Modell nicht gut genug für den realen Handel ist, könnte die Grundlage für die Entwicklung eines solchen Modells in Zukunft hilfreich sein.

Von den Redakteuren

Netologiekurse zum Thema:

• Online-Beruf für Datenanalysten
• Online-Beruf Data Scientist