Börsenprognosen sind heutzutage ein heißes Thema. Aufgrund des großen Spekulationsrisikos wird der Aktienmarkt stark von Nachrichten beeinflusst, z. B. von der Änderung der Politik durch die Federal Reserve, dem Zinssatz usw. In diesem Artikel wird beschrieben, wie man mit Hilfe von Python und der Technologie der künstlichen Intelligenz (Deep Neural Networks) US-Aktienkurse vorhersagen kann. Wir werden ein Programm in Python schreiben, das die Bewegung des US-Aktienmarktes anhand von historischen Daten vorhersagt.

Vorraussetzungen:

Numpy:

NumPy, kurz für Numerical Python, ist eine Python-Bibliothek, die für wissenschaftliche Berechnungen und Datenverarbeitung verwendet wird. Diese Bibliothek erleichtert die Ausführung von Python-Code auf Arrays und Matrizen anstelle von Listen. Sie hat viele Funktionen, die Ihre Mathematik schneller machen.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install numpy

Matplotlib:

Matplotlib ist eine sehr umfangreiche Bibliothek. Matplotlin wurde als grafische Benutzeroberfläche für ein Programm namens MATLAB entwickelt. Ingenieure und Datenwissenschaftler verwenden hauptsächlich MATLAB, obwohl es auch gut mit Python funktioniert. Da wir Diagramme und Graphen erstellen wollen, müssen wir Matplotlib installieren.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install Matplotlib

Tensorflow:

TensorFlow ist eine Open-Source-Softwarebibliothek für numerische Berechnungen mit Datenflussgraphen. Die Knoten des Graphen stellen mathematische Operationen dar, während die Kanten des Graphen die mehrdimensionalen Datenarrays (Tensoren) darstellen, die zwischen ihnen fließen. Die flexible Architektur ermöglicht es Ihnen, Berechnungen auf einer oder mehreren CPUs oder GPUs auf einem Desktop, Server oder mobilen Gerät mit einer einzigen API durchzuführen.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install --upgrade tensorflow

Sklearn:

SK-learn ist eine Python-Bibliothek, die den Prozess des maschinellen Lernens einfach zu verstehen macht

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install -U scikit-learn

Pandas_datareader:

Pandas DataReader ist ein Python-Paket, mit dem wir ein Pandas DataFrame-Objekt erstellen können, indem wir verschiedene Datenquellen aus dem Internet nutzen. Es wird häufig für Echtzeit-Aktienkursdatensätze verwendet.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install pandas-datareader

Schritt -1: Abhängigkeiten importieren

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.model_selection import PredefinedSplit
import pandas_datareader as web
import datetime as dt

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

Schritt 2: Laden der Daten

Dazu müssen wir angeben, ab welchem Punkt wir die Daten zur Vorhersage nehmen wollen, und wir haben auch das Tickersymbol definiert, das Sie von jedem Unternehmen über Google erhalten können 

company = 'FB'
start = dt.datetime(2014,1,1)
end = dt.datetime(2022,1,1)

# define ticker symbol
data = web.DataReader(company, 'yahoo', start, end)

Schritt -3: Aufbereitung der Daten

Zur Vorbereitung der Daten werden wir nicht den gesamten Datenrahmen verwenden, sondern nur den Schlusskurs. 

scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))

# how many days we want to look at the past to predict
prediction_days = 60

# defining two empty lists for preparing the training data
x_train = []
y_train = []

# we are counting from the 60th index to the last index
for x in range(prediction_days, len(scaled_data)):
    x_train.append(scaled_data[x-prediction_days:x, 0])
    y_train.append(scaled_data[x, 0])

x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))

Schritt -4: Erstellen des Modells und Festlegen der Schichten

Hier werden wir immer eine einzelne LSTM-Schicht einfügen, gefolgt von einer Dropout-Schicht in der Reihenfolge. Danach folgen dichte Schichten, die aus vielen Einheiten bestehen, wobei jede Einheit die Aktienkursprognose darstellt. Sie können die Anzahl der verwendeten Einheiten ändern, aber Sie müssen wissen, dass mehr Einheiten eine längere Trainingszeit bedeuten, da mehr Berechnungen pro Schicht erforderlich sind. 

model = Sequential()
# specify the layer
model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50))
model.add(Dropout(0.2))
# this is going to be a prediction of the next closing value
model.add(Dense(units=1))

Schritt -5: Kompilieren des Modells

model.compile(optimizer='adam', loss='mean_squared_error')
# fit the model in the training data
model.fit(x_train, y_train, epochs=25, batch_size=32)

Schritt -6: Testen des Modells

# Load Test Data
test_start = dt.datetime(2020,1,1)
test_end = dt.datetime.now()

test_data = web.DataReader(company, 'yahoo', test_start, test_end)

Mit den Daten dieses Unternehmens wollen wir nun herausfinden, wie vorhersagbar sie sind. Wir müssen Preise ermitteln, die Preise skalieren und dann einen Gesamtdatensatz erstellen, der sowohl aus geprüften als auch aus ungeprüften Informationen besteht. In der realen Welt würden wir als Daten die Schlusskurse verwenden, und dann werden wir alle Informationen zu einem großen Datensatz kombinieren, um unsere Vorhersagen zu treffen. 

actual_prices = test_data['Close'].values
total_dataset = pd.concat((data['Close'],test_data['Close']), axis=0)

model_input = total_dataset[len(total_dataset)- len(test_data) - prediction_days:].values
# reshaping the model
model_input = model_input.reshape(-1, 1)
# scaling down the model
model_input = scaler.transform(model_input)

Schritt -7: Vorhersage der Daten für den nächsten Tag

x_test = []
for x in range(prediction_days, len(model_input)):
    x_test.append(model_input[x-prediction_days:x, 0])
 
x_test = np.array(x_test)
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
 
predicted_price = model.predict(x_test)
predicted_price = scaler.inverse_transform(predicted_price)
 
# plot the test Predictions
plt.plot(actual_prices, color="black", label=f"Actual{company} price")
plt.plot(predicted_price, color='green', label="Predicted {company} Price")
plt.title(f"{company} Share price")
plt.xlabel('Time')
plt.ylabel(f'{company} share price')
plt.legend
plt.show()

Hier werden wir reale Daten als Eingabe verwenden, um die Daten für den nächsten Tag vorherzusagen. 

prediction = model.predict(real_data)
prediction = scaler.inverse_transform(prediction)
print(f"Prediction: {prediction}")

Ausgabe:

Letzte Worte

In diesem Blog haben wir gelernt, wie man den Aktienmarkt mit Python vorhersagen kann! Hier haben wir eine 60 Tage lange Zeitreihe von Daten genommen und dann die Daten des nächsten Tages vorhergesagt. Es ist ein etwas komplizierter Prozess, aber es ist auch nicht so schwer. Dennoch empfehle ich nicht, dies für den Handel zu verwenden. Ich betrachte dies eher als eine Lernerfahrung als alles andere. Ich hoffe, das Tutorial hat Ihnen gefallen, und wenn Sie Fragen haben, können Sie sie gerne unten stellen, und ich werde mein Bestes tun, um sie zu beantworten!

Here are some useful tutorials that you can read: