Maschinelles Lernen: Wir prognostizieren Aktienkurse an der Börse

    Die Übersetzerin Polina Kabirova, speziell für Netologiya , adaptierte den Artikel des Ingenieurs der Universität Cambridge, Vivek Palaniappan, über die Erstellung eines Modells unter Verwendung neuronaler Netze, die die Aktienkurse an der Börse vorhersagen können.

    Maschinelles Lernen und tiefes Lernen sind zu einer neuen wirksamen Strategie geworden, mit der viele Investmentfonds die Einnahmen steigern. In dem Artikel werde ich erläutern, wie neuronale Netze dabei helfen können, die Situation am Aktienmarkt vorherzusagen - beispielsweise den Aktienkurs (oder den Index). Im Zentrum des Textes steht mein in Python geschriebenes Projekt . Den vollständigen Code und Programmführer finden Sie auf GitHub. Weitere verwandte Artikel finden Sie im Medium- Blog .

    Neuronale Netze in der Wirtschaft


    Änderungen in der Finanzierung erfolgen nichtlinear, und manchmal scheint es, als ob die Aktienkurse völlig zufällig gebildet werden. Traditionelle Zeitreihenmethoden wie die Modelle ARIMA und GARCH sind effektiv, wenn die Serie stationär ist - ihre grundlegenden Eigenschaften ändern sich nicht mit der Zeit. Und dazu ist es erforderlich, dass die Serien mit der Hilfe vorverarbeitet log returnsoder auf Stationarität gebracht werden. Das Hauptproblem ergibt sich jedoch, wenn diese Modelle in einem realen Handelssystem implementiert werden, da beim Hinzufügen neuer Daten Stationarität nicht garantiert wird.

    Die Lösung für dieses Problem können neuronale Netze sein, die keine Stationarität erfordern. Neuronale Netzwerke sind anfangs sehr effektiv, um Verbindungen zwischen Daten zu finden, und können auf dieser Grundlage neue Daten vorhersagen (oder klassifizieren).

    Ein Data Science-Projekt besteht normalerweise aus den folgenden Operationen:

    1. Datenerfassung - stellt eine Reihe von erforderlichen Eigenschaften bereit.
    2. Die Datenvorverarbeitung ist oft ein erschreckender, aber notwendiger Schritt vor der Verwendung von Daten.
    3. Entwicklung und Implementierung des Modells - Auswahl des Typs des neuronalen Netzes und seiner Parameter.
    4. Backtesting-Modelle (Testen historischer Daten) sind der Schlüsselschritt jeder Handelsstrategie.
    5. Optimierung - Suche nach geeigneten Parametern.

    Die Eingabe für unser neuronales Netzwerk sind die Aktienkursdaten der letzten 10 Tage. Mit ihrer Hilfe prognostizieren wir die Preise am nächsten Tag.

    Datenerfassung


    Glücklicherweise sind die für dieses Projekt erforderlichen Daten bei Yahoo Finance zu finden. Daten können mithilfe ihrer Python-API pdr.get_yahoo_data(ticker, start_date, end_date)oder direkt von der Site erfasst werden .

    Vorläufige Datenverarbeitung


    In unserem Fall sollten die Daten in Trainingssätze unterteilt werden, die aus 10 vergangenen Preisen und den Preisen am nächsten Tag bestehen. Dafür habe ich eine Klasse definiert Preprocessing, die mit Trainings- und Testdaten arbeitet. Innerhalb der Klasse habe ich eine Methode definiert get_train(self, seq_len), die die Eingabe- und Ausgabedaten des Trainings in NumPyArrays umwandelt und dabei eine bestimmte Fensterlänge angibt (in unserem Fall 10). Der gesamte Code sieht so aus:

    defgen_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 Testdaten X_testund konvertiert Y_test.

    Neuronale Netzwerkmodelle


    Für das Projekt habe ich zwei Modelle neuronaler Netzwerke verwendet: Rumelharts Multilayer Perceptron (MLP) -Perzeptron und LSTM-Modell (Long Short Term Model). Ich werde kurz über die Funktionsweise dieser Modelle sprechen. Lesen Sie mehr über MLP in einem anderen Artikel und über die Arbeit von LSTM - im Material von Jacob Aungiers.

    MLP ist die einfachste Form neuronaler Netze. Die Eingabedaten gelangen in das Modell und mit Hilfe bestimmter Gewichtungen werden die Werte durch ausgeblendete Ebenen geleitet, um die Ausgabedaten zu erhalten. Der Lernalgorithmus stammt von der Rückwärtspropagation durch verborgene Schichten, um den Wert der Gewichte jedes Neurons zu ändern. Das Problem bei diesem Modell ist der Mangel an "Speicher". Es ist unmöglich festzustellen, was die vorherigen Daten waren und wie sie die neuen beeinflussen können und sollen. Im Zusammenhang mit unserem Modell können Unterschiede zwischen den Daten zweier Datensätze in zehn Tagen erheblich sein, aber MLPs können solche Beziehungen nicht analysieren.

    Hierzu wird LSTM oder Recurrent Neural Networks (RNN) verwendet. RNNs speichern bestimmte Informationen zu den Daten für die spätere Verwendung, sodass das neuronale Netzwerk die komplexe Struktur der Beziehungen zwischen den Aktienkursdaten analysieren kann. Bei RNN tritt jedoch ein verschwindendes Gradientenproblem auf. Der Gradient nimmt ab, weil die Anzahl der Schichten zunimmt und der Lerngrad (Wert unter eins) mehrmals multipliziert wird. Lösen Sie dieses Problem LSTM und erhöhen Sie die Effizienz.

    Modellimplementierung


    Um das von mir verwendete Modell zu implementieren Keras, werden dort die Ebenen schrittweise hinzugefügt und definieren nicht das gesamte Netzwerk auf einmal. So können wir schnell die Anzahl und den Typ der Schichten ändern und das neuronale Netzwerk optimieren.

    Eine wichtige Phase im Umgang mit Aktienkursen ist die Normalisierung der Daten. Normalerweise subtrahieren Sie dazu den Durchschnittsfehler und dividieren durch den Standardfehler. Aber wir brauchen dieses System für einen bestimmten Zeitraum im realen Handel. Daher ist die Verwendung von Statistiken möglicherweise nicht der genaueste Weg, um Daten zu normalisieren. Daher habe ich einfach alle Daten in 200 geteilt (eine beliebige Zahl, gegenüber der alle anderen Zahlen klein sind). Und obwohl es scheint, dass eine solche Normalisierung durch nichts gerechtfertigt ist und keinen Sinn ergibt, ist es effektiv, sicherzustellen, dass die Gewichte im neuronalen Netzwerk nicht zu groß werden.

    Beginnen wir mit einem einfacheren Modell - MLP. In Keras wird eine Sequenz erstellt und dichte Schichten darüber hinzugefügt. 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 erstellten wir MLPs mit verborgenen Schichten, jeweils einhundert Neuronen. Und nun ein wenig zum Optimierer. Bekanntheit erlangt das Adam-Verfahren (Adaptive Moment Estimation) - ein effizienter Optimierungsalgorithmus im Vergleich zum stochastischen Gradientenabstieg . Es gibt zwei weitere Erweiterungen des stochastischen Gradientenabstiegs - Adams Vorteile sind unmittelbar vor dem Hintergrund sichtbar:

    AdaGrad unterstützt die etablierte Lerngeschwindigkeit, die die Ergebnisse verbessert, wenn Gradienten auseinandergehen (z. B. bei Problemen mit der natürlichen Sprache und der Bildverarbeitung).

    Rmsprop- unterstützt die festgelegte Lernrate, die abhängig von den Durchschnittswerten der letzten Steigungen für das Gewicht variieren kann (z. B. wie schnell sich diese ändert). Dies bedeutet, dass der Algorithmus mit instabilen Problemen (z. B. Rauschen) gut zurechtkommt.

    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 noch einmal, 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. Das wird so gemacht:

    model.evaluate(X_test, Y_test)

    Informationen, die als Ergebnis des Tests erhalten werden, können verwendet werden, um die Fähigkeit des Modells zur Vorhersage von Aktienkursen zu bewerten.

    Für das LSTM-Modell wird ein ähnliches Verfahren verwendet, daher werde ich den Code zeigen und ein wenig erläutern:

    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 abhängig von Ihrem 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 mit Hilfe von Trainingsdaten vorbereitet und anhand von Testdaten getestet haben, können wir das Modell anhand historischer Daten testen. Dies geschieht wie folgt:

    defback_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 „Überlebensfehler“ (Überlebensverzerrung), Tendenz (Look Ahead), sich ändernde Marktbedingungen und Transaktionskosten berücksichtigt werden. Da dies nur ein Bildungsprojekt ist, gibt es genug einfaches Backtesting.


    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 Netzwerke und Machine Learning-Modelle komplexe stabile Verbindungen zwischen Parametern aufbauen können.

    Hyperparameter-Optimierung


    Um die Modellergebnisse nach dem Testen zu verbessern, ist häufig eine Optimierung erforderlich. 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 Suchen von Hyperparametern: Von der Auswahl der Parameter durch das Raster bis zu stochastischen Methoden.

    Ich bin zuversichtlich, dass mit der Optimierung von Wissensmodellen im Bereich des maschinellen Lernens diese ein neues Niveau erreichen. Versuchen Sie, das Modell so zu optimieren, dass es besser funktioniert als meines. Vergleichen Sie das Ergebnis mit dem oben angegebenen Zeitplan.

    Fazit


    Das maschinelle Lernen entwickelt sich ständig weiter - täglich werden neue Methoden entwickelt. Daher ist es wichtig, ständig zu lernen. Der beste Weg, dies zu tun, ist die Erstellung interessanter Projekte, beispielsweise zum Erstellen von Modellen zur Vorhersage der Aktienkurse. Und obwohl mein LSTM-Modell für den Einsatz im realen Handel nicht gut genug ist, kann die Grundlage für die Entwicklung eines solchen Modells in der Zukunft hilfreich sein.

    Aus dem Editor


    Kurse "Netologie" zum Thema:


    Jetzt auch beliebt: