Verschaffen Sie sich einen Vorteil auf jedem Markt
196
0
Inhalt
- Zusammenfassung
- Einführung
- Überblick über die Strategie: Alternative Datenquellen
- Techniken des maschinellen Lernens
- Entwicklung der Strategie
- Schlussfolgerung
- Empfehlungen
Zusammenfassung
Heute werden wir eine solide Handelsstrategie entwickeln, die Händlern einen erheblichen Wettbewerbsvorteil auf verschiedenen Märkten verschafft. Während sich herkömmliche Marktteilnehmer bei ihrer Entscheidungsfindung ausschließlich auf eine Kombination aus kursbezogenen Daten, technischen Indikatoren und öffentlichen Nachrichtenmeldungen verlassen, verfolgt unsere Strategie einen bahnbrechenden Ansatz, indem sie alternative Datenquellen nutzt, die von der Mehrheit weitgehend noch nicht berücksichtig werden.
Die Prämisse unserer Strategie liegt in der Integration alternativer Daten, eine Option, die von den etablierten Marktteilnehmern oft übersehen wird. Durch die Nutzung dieser ungenutzten Datenquellen und die Anwendung von Techniken des maschinellen Lernens können wir uns in die Lage versetzen, einzigartige Einblicke und Perspektiven zu gewinnen, die für unsere Strategie exklusiv sind.
In unserer Untersuchung werden wir die Daten der St. Louis Federal Reserve Bank untersuchen und dabei insbesondere ihre umfassende ökonometrische Zeitreihendatenbank FRED nutzen. FRED ist für die Öffentlichkeit jederzeit zugänglich und bietet zweifellos Daten, die für eine fundierte Entscheidungsfindung im Handel entscheidend sind. Darüber hinaus dienen Daten von Zentralbanken wie der St. Louis Fed oft als Frühindikatoren, die es uns ermöglichen, Ein- und Ausstiege effektiv zu timen.
Außerdem sind diese Daten immun gegen externe Manipulationen, was sie zu einem idealen Kandidaten für die Integration in unsere Handelsstrategie macht.
Dieser Artikel soll als praktischer Leitfaden dienen, der die einfache Nutzung von Python und MetaTrader 5 für die Entwicklung innovativer Handelsstrategien demonstriert. Unser Engagement für Klarheit und Einfachheit sorgt dafür, dass jeder Aspekt deutlich erklärt wird, sodass die Leser unseren Ansatz mühelos verstehen und noch heute loslegen können!
Einleitung: In diesem Artikel soll gezeigt werden, wie man alternative Daten problemlos in Handelsstrategien einsetzen kann.
Am Ende dieses Artikels werden die Leser Einblicke in die folgenden Schlüsselbereiche erhalten:- Wie alternative Daten die Entscheidungsfindung trotz Unsicherheit und verrauschten Daten unterstützen können.
- Techniken für das Screening und die Identifizierung zuverlässiger Quellen für alternative Daten.
- Bewährte Praktiken für die Analyse und Vorverarbeitung von alternativen Daten für die Analyse.
- Entwicklung robuster Handelsstrategien, die alternative Datenquellen integrieren, um den Entscheidungsprozess zu verbessern.
Ein Beispiel für die Auswirkungen alternativer Daten ist die strategische Nutzung von Satellitenbildern. Fortgeschrittene Händler nutzen Satellitenbilder zur Überwachung des Schiffsverkehrs oder zur Beobachtung der Lagerbestände von Öltankern. Diese einzigartigen Datenpunkte ermöglichen es Händlern, profitable Handelsmöglichkeiten zu entdecken, die sonst verborgen bleiben würden.
Auch wenn die Nutzung von Satellitenbildern eher unter zahlungsstarken Händlern verbreitet ist, zeigt dieser Artikel, wie jeder Händler frei verfügbare alternative Daten nutzen kann, um dem Markt voraus zu sein. Weiters können wir durch den Einsatz von Modellen des maschinellen Lernens mehrere Datenquellen gleichzeitig analysieren und so die Entscheidungsfähigkeit der Mitarbeiter weiter verbessern.
Überblick über die Handelsstrategie: Alternative Datenquellen
Unsere Handelsstrategie ist so konzipiert, dass sie leicht verständlich ist. Wir werden konventionelle Marktdaten von unserem MetaTrader 5-Terminal mit alternativen Daten der St. Louis Federal Reserve Bank integrieren, wobei wir uns speziell auf die Vorhersage der zukünftigen Kursbewegungen des GBPUSD-Paares konzentrieren.
Um dies zu erreichen, werden wir zwei wichtige Wirtschaftsdatensätze als alternative Datenquellen nutzen. Der erste Datensatz enthält Informationen über das Britische Pfund und bietet eine Zeitreihe von Zinssätzen, die für Bankgeschäfte außerhalb der Öffnungszeiten auf dem britischen Pfundmarkt berechnet werden. Diese Zinsschwankungen dienen als Indikator für das Niveau der institutionellen Nachfrage nach Pfund Sterling und liefern wertvolle Hinweise für unsere Prognosemodelle.
Der zweite Datensatz enthält Informationen über den US-Dollar und eine Zeitreihe der Zinssätze für Übernachtkredite an amerikanische Banken, die von der Federal Reserve verwaltet werden. Die Kontrolle der Federal Reserve über diese Zinssätze durch geldpolitische Anpassungen bietet alternative Einblicke in wirtschaftliche Trends, die sich auf den USD auswirken können.
Durch die Analyse und Interpretation dieser wirtschaftlichen Zeitreihendaten und den Einsatz von Techniken des maschinellen Lernens können wir hoffentlich unser Ziel erreichen, Frühindikatoren aufzudecken, die uns einen Wettbewerbsvorteil auf dem Markt verschaffen.
Der Eckpfeiler der Wirksamkeit unserer Strategie hängt von der Sicherung einer zuverlässigen Quelle für alternative Daten ab. Die Verfügbarkeit zuverlässiger alternativer Datenquellen hängt von den Märkten ab, auf denen Sie handeln. Für synthetische Märkte, die von Zufallszahlengeneratoren erzeugt werden, gibt es praktisch keine alternativen Datenquellen. Der Grund dafür ist, dass synthetische Märkte von der Außenwelt unabhängig sind.
- Glaubwürdigkeit: Wie kommt Ihre Quelle für alternative Daten überhaupt an die Daten? Prüfen Sie die Zuverlässigkeit der Informationskanäle, auf die sie angewiesen sind. Fragen wie „Wie erhalten sie ihre Informationen?“ und „Sind ihre Informationskanäle vertrauenswürdig?“ sind für die Beurteilung der Glaubwürdigkeit entscheidend. Jeder Zweifel an diesen Aspekten ist ein Zeichen dafür, dass eine gründlichere Bewertung erforderlich ist.
- Häufigkeit der Aktualisierungen: Unser Schwerpunkt liegt auf alternativen Datenquellen, die täglich aktualisiert werden und sich an unserem Handelszeitrahmen orientieren. Es ist jedoch wichtig zu wissen, dass nicht alle Quellen tägliche Aktualisierungen anbieten; einige können monatlich oder jährlich aktualisiert werden, daher sollten Sie eine Quelle wählen, die mit Ihrer gewünschten Handelsfrequenz übereinstimmt.
- Reputation: Über die Glaubwürdigkeit hinaus sollten Sie Quellen mit einer seriösen Erfolgsbilanz und einem nachgewiesenen Interesse an der Wahrung der Genauigkeit den Vorzug geben. Ein seriöser Anbieter erhöht nicht nur die Glaubwürdigkeit unserer Daten, sondern zeigt auch, dass er verantwortlich ist.
- Transparente Präsentation: Entscheiden Sie sich für Anbieter, die Daten transparent und benutzerfreundlich darstellen. Klarheit und Einfachheit der Datendarstellung sind für eine wirksame Entscheidungsfindung von entscheidender Bedeutung, insbesondere angesichts der kognitiven Belastung, die mit komplexen Daten verbunden ist.
- Preisstruktur: Bewertung der Preismodelle alternativer Datenquellen unter Berücksichtigung unserer Bedürfnisse und Budgetbeschränkungen. Einige Quellen können kostenlos sein, andere wiederum kostenpflichtig. Unsere Wahl sollte mit dem Wertangebot der jeweiligen Quelle übereinstimmen.
- Bedingungen und Konditionen: Prüfen Sie sorgfältig die Bedingungen und Konditionen alternativer Datenquellen, insbesondere derjenigen, die eine Zahlung erfordern, und machen Sie sich mit ihnen vertraut. Ein klares Verständnis der Nutzungsbeschränkungen und -einschränkungen gewährleistet eine fundierte Entscheidungsfindung und verhindert unbeabsichtigte Probleme bei der Einhaltung der Vorschriften.
Zusammenfassend lässt sich sagen, dass eine strenge Bewertung alternativer Datenquellen auf der Grundlage von Glaubwürdigkeit, Aktualisierungshäufigkeit, Reputation, Transparenz, Preisgestaltung und Geschäftsbedingungen unerlässlich ist, um Daten im Rahmen unserer Handelsstrategie effektiv zu nutzen.
Wir werden nun damit beginnen, einige alternative Daten zu untersuchen, die von der St. Louis Federal Reserve Bank stammen. Es gibt 2 Möglichkeiten, Daten von der St. Louis Fed abzurufen:
- Programmatische Verwendung der FRED-Python-Bibliothek
- Manuell auf der FRED-Website
Wenn Sie diese Datensätze zum ersten Mal verwenden, empfehle ich Ihnen, die Daten zunächst manuell zu erfassen. Dies ist ratsam, denn auf der FRED-Website finden Sie nützliche Hinweise und Informationen zu jedem Datensatz, wie er erfasst wurde, was die Daten darstellen, ob sie saisonal bereinigt sind oder nicht, die Maßeinheiten und Skalen der Messungen und andere Details dieser Art. Sobald Sie mit der Art der Daten vertraut sind, können Sie dazu übergehen, diese programmatisch zu erfassen. Für unsere erste Demonstration wurden die Datensätze manuell von der Website der St Louis Federal Reserve Bank heruntergeladen. Wir werden bei der Ausarbeitung der Strategie zu einem programmatischen Ansatz übergehen.
Das erste, was wir tun werden, ist das Sammeln von Marktdaten aus unserem MetaTrader 5 mit einem MQL5-Skript, ich bevorzuge das Sammeln der Daten auf diese Weise, weil Sie jede Vorverarbeitung, die Sie auf der MQL5-Seite, wo Sie unbegrenzten Zugang zu Daten haben, durchführen können. Unser Drehbuch ist bescheiden einfach.
- Wir beginnen mit der Deklaration von Handlern für unsere technischen Indikatoren, wir werden 4 gleitende Durchschnitte verwenden.
- Dann deklarieren wir Puffer, um die Messwerte unserer gleitenden Durchschnitte zu speichern; die Puffer sind in unserem Fall dynamische Arrays.
- Dann brauchen wir einen Namen für unsere Datei. Unserer ist der Name des Paares, mit dem wir handeln, gefolgt von der Zeichenkette „Market Data As Series“, und die Datei hat das Format CSV.
- Anschließend geben wir an, wie viele Daten wir sammeln möchten.
- Beachten Sie, dass das Skript mit dem aktuellen Zeitrahmen des Charts arbeitet, auf den es angewendet wird.
- Wir sind nun bei unserem OnStart()-Ereignisbehandlung angelangt, der das Herzstück unseres Skripts darstellt.
- Wir beginnen mit der Initialisierung aller 4 technischen Indikatoren.
- Dann kopieren wir die Indikatorwerte in die zuvor erstellten Arrays.
- Sobald dies geschehen ist, erstellen wir einen File-Handler, der unsere Datei erstellt, schreibt und schließt.
- Wir verwenden dann eine einfache for-Schleife, um die Arrays zu durchlaufen und sie in unsere CSV-Datei zu schreiben. Beachten Sie, dass wir bei der ersten Iteration unserer Schleife die Spaltenüberschriften schreiben, danach geben wir die gewünschten Werte aus.
- Sobald die Schleife abgeschlossen ist, schließen wir unsere Datei mit Hilfe des File-Handles und sind nun bereit, die Daten von unserem MetaTrader 5 Terminal mit unseren alternativen Daten zusammenzuführen.
#property copyright "Gamuchirai Zororo Ndawana" #property link "https://www.mql5.com" #property version "1.00" //---Our handlers for our indicators int ma_handle_5; int ma_handle_15; int ma_handle_30; int ma_handle_150; //---Data structures to store the readings from our indicators double ma_reading_5[]; double ma_reading_15[]; double ma_reading_30[]; double ma_reading_150[]; //---File name string file_name = _Symbol + " " + " Market Data As Series.csv"; //---Amount of data requested int size = 1000000; int size_fetch = size + 100; void OnStart() { //---Setup our technical indicators ma_handle_5 = iMA(_Symbol,PERIOD_CURRENT,5,0,MODE_EMA,PRICE_CLOSE); ma_handle_15 = iMA(_Symbol,PERIOD_CURRENT,15,0,MODE_EMA,PRICE_CLOSE); ma_handle_30 = iMA(_Symbol,PERIOD_CURRENT,30,0,MODE_EMA,PRICE_CLOSE); ma_handle_150 = iMA(_Symbol,PERIOD_CURRENT,150,0,MODE_EMA,PRICE_CLOSE); //---Copy indicator values CopyBuffer(ma_handle_5,0,0,size_fetch,ma_reading_5); ArraySetAsSeries(ma_reading_5,true); CopyBuffer(ma_handle_15,0,0,size_fetch,ma_reading_15); ArraySetAsSeries(ma_reading_15,true); CopyBuffer(ma_handle_30,0,0,size_fetch,ma_reading_30); ArraySetAsSeries(ma_reading_30,true); CopyBuffer(ma_handle_150,0,0,size_fetch,ma_reading_150); ArraySetAsSeries(ma_reading_150,true); //---Write to file int file_handle=FileOpen(file_name,FILE_WRITE|FILE_ANSI|FILE_CSV,","); for(int i=-1;i<=size;i++){ if(i == -1){ FileWrite(file_handle,"Time","Open","High","Low","Close","MA 5","MA 15","MA 30","MA 150"); } else{ FileWrite(file_handle,iTime(_Symbol,PERIOD_CURRENT,i), iOpen(_Symbol,PERIOD_CURRENT,i), iHigh(_Symbol,PERIOD_CURRENT,i), iLow(_Symbol,PERIOD_CURRENT,i), iClose(_Symbol,PERIOD_CURRENT,i), ma_reading_5[i], ma_reading_15[i], ma_reading_30[i], ma_reading_150[i] ); } } } //+------------------------------------------------------------------+
Wir sind nun bereit, unsere alternativen Daten zusammen mit unseren Marktdaten zu untersuchen.
Wie immer beginnen wir mit dem Import der erforderlichen Pakete.
import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns
Jetzt lesen wir die Daten ein, die wir aus unserem MQL5-Skript exportiert haben.
GBPUSD = pd.read_csv("C:\\Enter\\Your\\Path\\Here\\MetaQuotes\\Terminal\\NVUSDVJSNDU3483408FVKDL\\MQL5\\Files\\GBPUSD Market Data As Series.csv") Bei der Aufbereitung von Marktdaten für das maschinelle Lernen sollten Sie darauf achten, dass der heutige Preis an letzter Stelle und der älteste Preis an erster Stelle steht.
GBPUSD = GBPUSD[::-1] Dann müssen wir den Index zurücksetzen.
GBPUSD.reset_index(inplace=True)
Legen wir fest, wie weit wir vorausschauen wollen.
look_ahead = 30 splits = 30
Jetzt müssen wir das Ziel vorbereiten.
GBPUSD["Target"] = GBPUSD["Close"].shift(-look_ahead) GBPUSD.dropna(inplace=True)
Jetzt müssen wir das Datum zum Index machen, damit wir unsere Marktdaten später leicht mit unseren alternativen Daten abgleichen können.
GBPUSD["Time"] = pd.to_datetime(GBPUSD["Time"]) GBPUSD.set_index("Time",inplace=True)
Der erste alternative Datensatz, den wir betrachten werden, ist der Daily Sterling Overnight Index Average (SOIA). Es handelt sich um den Durchschnitt der Zinssätze, die den Banken für die Ausleihe von Sterlings außerhalb der normalen Geschäftszeiten berechnet werden.
Wenn die durchschnittlichen Zinssätze für Pfund Sterling steigen, während die durchschnittlichen Zinssätze für den Dollar sinken, könnte dies ein Zeichen dafür sein, dass das GBP auf institutioneller Ebene stärker wird als der USD.
SOIA = pd.read_csv("C:\\Enter\\Your\\Path\\Here\\Downloads\\FED Data\\Daily Sterling Overnight Index Average\\IUDSOIA.csv") Bereinigen wir die alternativen Daten. Machen Sie zunächst die Datumsspalte zu einem Datumsobjekt.
SOIA["DATE"] = pd.to_datetime(SOIA["DATE"])
Unser Datensatz enthält Punkte, die vermutlich fehlende Beobachtungen darstellen sollen. Wir ersetzen alle Punkte durch Nullen und ersetzen dann die Nullen durch den Durchschnittswert der Spalte.
SOIA["IUDSOIA"] = SOIA["IUDSOIA"].replace(".","0") SOIA["IUDSOIA"] = pd.to_numeric(SOIA["IUDSOIA"]) non_zero_mean = SOIA.loc[SOIA['IUDSOIA'] != 0, 'IUDSOIA'].mean() SOIA['IUDSOIA'] = SOIA['IUDSOIA'].replace(0, non_zero_mean)
Als Nächstes machen wir das Datum zum Index.
SOIA.set_index("DATE",inplace=True) Die nächste Quelle alternativer Daten, die wir betrachten werden, ist die Secured Overnight Financing Rate (SOFR). Es handelt sich um die Kosten für besicherte Übernachtkredite, die täglich von der New Yorker Federal Reserve Bank veröffentlicht werden.
SOFR = pd.read_csv("C:\\Enter\\Your\\Path\\Here\\Downloads\\FED Data\\Secured Overnight Financing Rate\\SOFR.csv") Bitte beachten Sie, dass die Vorverarbeitungsschritte für den SOFR-Datensatz identisch mit denen für den SOIA-Datensatz sind. Um den Artikel von Anfang bis Ende übersichtlich zu halten, lassen wir diese Schritte weg.
Fügen wir nun die 3 vorhandenen Datenrahmen zusammen. Indem wir left_index und right_index auf true setzen, stellen wir sicher, dass beide Datensätze nur an Tagen abgeglichen werden, an denen wir vollständige Beobachtungen für jeden von ihnen haben. Der GBPUSD-Datensatz enthält beispielsweise keine Datensätze über das Wochenende, daher sind alle alternativen Datenpunkte, die über das Wochenende beobachtet wurden, nicht in unserem endgültigen fusionierten Datenrahmen enthalten.
merged_df = SOIA.merge(SOFR,left_index=True,right_index=True) merged_df = merged_df.merge(GBPUSD,left_index=True,right_index=True)
Dann müssen wir unseren Index zurücksetzen.
merged_df.reset_index(inplace=True)
merged_df.drop(columns=["index"],inplace=True) Definieren wir unsere Prädiktoren.
normal_predictors = ['Open', 'High', 'Low', 'Close', 'MA 5', 'MA 15','MA 30', 'MA 150'] alternative_predictors = ['IUDSOIA', 'SOFR'] all_predictors = normal_predictors + alternative_predictors
Anschließend wird ein Datenrahmen erstellt, in dem die Fehlerniveaus der einzelnen Kombinationen von Prädiktoren gespeichert werden.
accuracy = pd.DataFrame(columns=["Normal","Alternative","All"],index=np.arange(0,splits))
So sieht unser Datenrahmen jetzt aus.
merged_df
Abb. 1: Unser Datensatz, der sowohl unsere normalen Daten als auch unsere alternativen Daten enthält.
Die erste Spalte ist der durchschnittliche Zinssatz für das Pfund Sterling, die zweite Spalte enthält den durchschnittlichen Zinssatz für den amerikanischen Dollar. Von dort aus sollten Ihnen die folgenden Spalten bereits bekannt sein. Denken Sie daran, dass das Ziel der 30 Tage in der Zukunft liegende Schlusskurs ist.
Zum Schluss exportieren wir unseren zusammengeführten Datenrahmen zur späteren Verwendung in eine csv-Datei.
merged_df.to_csv('Alternative Data Target Look Ahead 30.csv') Lassen Sie uns unsere Daten skalieren.
from sklearn.preprocessing import StandardScaler scaled_data = merged_df.loc[:,all_predictors] scaler = StandardScaler() scaler.fit(scaled_data) scaled_data = pd.DataFrame(scaler.transform(scaled_data),index=merged_df.index,columns=all_predictors)
Lassen Sie uns nun unser Modell trainieren und sehen, ob unsere alternativen Daten uns helfen oder behindern.
from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error from sklearn.model_selection import TimeSeriesSplit
Teilen wir die Daten in Train und Test auf.
tscv = TimeSeriesSplit(gap=look_ahead+10,n_splits=splits)
for i,(train,test) in enumerate(tscv.split(merged_df)):
model = LinearRegression()
model.fit(scaled_data.loc[train[0]:train[-1],all_predictors],merged_df.loc[train[0]:train[-1],"Target"])
accuracy["All"][i] = mean_squared_error(merged_df.loc[test[0]:test[-1],"Target"],model.predict(scaled_data.loc[test[0]:test[-1],all_predictors])) Jetzt stellen wir die Ergebnisse als Boxplots dar.
fig,axs = plt.subplots(1,3,sharex=True,sharey=True,figsize=(16,4)) for i,ax in enumerate(axs.flat): ax.boxplot(merged_df.iloc[:,i]) ax.set_title(accuracy.columns[i])
Abb. 2: Analyse der Fehlerwerte bei Verwendung normaler Daten (links), alternativer Daten (Mitte) und aller verfügbaren Daten (rechts)
Interpretieren wir die Ergebnisse: Es ist deutlich zu erkennen, dass sowohl der normale Satz von Prädiktoren als auch der alternative Satz von Prädiktoren lange Ausreißer haben, die bis zum oberen Rand der Grafik reichen. Das letzte Diagramm, das sowohl die normalen als auch die alternativen Prädiktoren enthält, hat jedoch eine gepresste Form. Diese gepresste Form ist wünschenswert, weil sie zeigt, dass wir bei der Verwendung beider Prädiktorengruppen zusammen weniger Fehlerabweichungen erhalten. Unsere Genauigkeit ist in der letzten Grafik stabil, aber in den ersten beiden Grafiken, in denen wir uns entweder vollständig auf normale Daten oder auf alternative Daten verlassen, ist unsere Genauigkeit nicht so stabil.
Wir können auch prüfen, ob es in unseren Daten irgendwelche Interaktionseffekte gibt. Wir werden ein Streudiagramm erstellen, das das Ziel auf der y-Achse und den Pfund-Zinssatz auf der x-Achse darstellt.
sns.scatterplot(x=merged_df["IUDSOIA"],y=merged_df["Target"])
Abb. 3: Analyse der Beziehung zwischen dem Zinssatz für Sterlings und dem zukünftigen Wert des Paares GBPUSD.
Jede Linie, die von oben nach unten verläuft, stellt dar, wie sich das Ziel verändert, wenn der Sterling-Zinssatz festgelegt ist. Die Tatsache, dass wir unterschiedliche Zielwerte beobachten können, obwohl unser Pfund-Zinssatz fix ist, ist ein eindeutiges Zeichen für Interaktionseffekte in unseren Daten. Dies könnte ein Hinweis darauf sein, dass andere starke Kräfte am Werk sind, die das Ziel über die von uns erhobenen alternativen Daten hinaus beeinflussen.
Maschinelle Lerntechniken
Die Auswahl eines geeigneten maschinellen Lernverfahrens hängt von der Art der Daten ab, die Ihnen vorliegen. Bedenken Sie Folgendes:
- Größe des Datensatzes: Bei kleinen Datensätzen mit weniger als zehntausend Zeilen oder weniger als 30 Spalten ist es ratsam, einfachere Modelle zu verwenden, um das Risiko einer Überanpassung zu mindern. Komplexe Modelle wie tiefe neuronale Netze können mit solch begrenzten Daten nur schwer effektiv lernen.
- Datenrauschen: Verrauschte Datensätze, d. h. Datensätze mit fehlenden Datenpunkten oder zufälligen, unerklärlichen Schwankungen, sind besser für einfachere Modelle geeignet. Komplexe Modelle weisen in der Regel eine hohe Varianz auf, sodass sie bei verrauschten Daten eher zu einer Überanpassung neigen, und außerdem sind wir an besonders verrauschten Markttagen vielleicht sogar besser dran, wenn wir auf sie verzichten.
- Dimensionalität der Daten: In Fällen, in denen der Datensatz eine große Anzahl von Spalten aufweist, können Vorverarbeitungstechniken von Vorteil sein. Verwenden Sie Modelle, die mit hochdimensionalen Daten umgehen können, und wenden Sie eine Merkmalsauswahl und Dimensionalitätsreduktion an.
- Datenumfang und Rechenleistung: Wenn Sie über große Datensätze mit akzeptablem Rauschen verfügen und obendrein Zugang zu ausreichenden Rechenressourcen haben, dann kann dies den Einsatz anspruchsvoller Modelle wie tiefer neuronaler Netze rechtfertigen. Diese Modelle können komplexe Muster und Beziehungen in den Daten effektiv erfassen, wenn sie über angemessene Rechenkapazitäten und saubere Daten verfügen.
Wir werden nun zeigen, wie Sie ein gutes Modell für Ihre Daten auswählen können.
Wir beginnen damit, die benötigten Bibliotheken zu importieren.
import statistics as st import pandas as pd import numpy as np import seaborn as sns import matplotlib.pyplot as plt from sklearn.linear_model import Lasso,Ridge,LinearRegression from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import TimeSeriesSplit from sklearn.metrics import mean_squared_error from sklearn.svm import SVR from sklearn.preprocessing import StandardScaler from xgboost import XGBRegressor
Jetzt lesen wir die Daten aus der exportierten csv-Datei ein. Die CSV-Datei enthielt alle unsere zusammengeführten Daten.
csv = pd.read_csv("C:\\Enter\\Your\\Path\\Here\\Alternative Data.csv") Machen wir uns bereit, die Daten zu skalieren.
predictors = ['IUDSOIA', 'SOFR', 'Open', 'High', 'Low', 'Close'] target = 'Target' scaled_data = csv.loc[:,predictors] scaler = StandardScaler() scaler.fit(scaled_data) scaled_data = scaler.transform(scaled_data)
Lassen Sie uns unsere Modelle trainieren.
splits = 10 gap = 30 models = ['Linear','Lasso','Ridge','Random Forest','Linear SVR','Sigmoid SVR','RBF SVR','2 Poly SVR','3 Poly SVR','XGB']
Bereiten wir die Aufteilung in Train/Test vor und erstellen dann einen Datenrahmen, um die Fehlermetriken zu speichern.
tscv = TimeSeriesSplit(n_splits=splits,gap=gap) error_df = pd.DataFrame(index=np.arange(0,splits),columns=models)
Jetzt können wir die Fehlermetriken unseres Modells beobachten.
for i,(train,test) in enumerate(tscv.split(csv)): model=XGBRegressor() model.fit(scaled_data.loc[train[0]:train[-1],predictors],csv.loc[train[0]:train[-1],target]) error_df.iloc[i,9] =mean_squared_error(csv.loc[test[0]:test[-1],target],model.predict(scaled_data.loc[test[0]:test[-1],predictors])) error_df
Abb. 4: Die Fehlerwerte, die wir von jedem der von uns angepassten Modelle erhalten haben.
Lassen Sie uns einige der Daten als Boxplots darstellen.
fig , axs = plt.subplots(2,5,figsize=(20,20),sharex=True) for i,ax in enumerate(axs.flat): ax.boxplot(error_df.iloc[:,i]) ax.set_title(error_df.columns[i])
Abb. 5: Die Fehlerwerte einiger der von uns verwendeten linearen Modelle.
Abb. 6: Die Fehlerwerte einiger der von uns verwendeten nicht-linearen Modelle.
Wir werden einige der erhaltenen zusammenfassenden Statistiken anzeigen.
| Varianz | Fehler |
|---|---|
| Lineare Varianz: 1.3365981802501968e-06 | Linearer mittlerer quadratischer Fehler: 0.0022242681292296462 |
| Lasso-Varianz: 3.0466413126186177e-05 | Lasso mittlerer quadratischer Fehler: 0.004995731270431843 |
| Ridge Varianz: 2.5678314939547713e-06 | Mittlerer quadratischer Fehler der Stege: 0.002467126140156681 |
| Random Forest Varianz: 2.607918492340197e-06 | Mittlerer quadratischer Fehler des Random Forest: 0.002632579355696408 |
| Lineare SVR-Varianz: 3.825627012092798e-05 | Linearer SVR mittlerer quadratischer Fehler: 0.004484702122899226 |
| Sigmoidale SVR-Varianz: 27.654341711864102 | Sigmoid SVR mittlerer quadratischer Fehler: 1.6693947903605928 |
| RBF SVR-Varianz: 4.1654658535332505e-05 | Mittlerer quadratischer Fehler der RBF SVR: 0.004992333849448852 |
| 2 Poly SVR Varianz: 6.739873404310582e-05 | 2 Poly SVR mittlerer quadratischer Fehler: 0.008163708245600027 |
| 3 Poly SVR-Varianz: 0.0005393054392191576 | 3 Poly SVR mittlerer quadratischer Fehler: 0.018431036676781344 |
| XGB-Varianz: 7.053078880392137e-06 | XGB mittlerer quadratischer Fehler: 0.003163819414983548 |
Es fällt auf, dass keines der Modelle besonders gut abschneidet, sondern sich alle mehr oder weniger in der gleichen Leistungsspanne befinden. Unter solchen Umständen kann das einfachere Modell die beste Wahl sein, da es weniger wahrscheinlich zu einer Überanpassung führt. Daher werden wir in diesem Beispiel die lineare Regression als Modell unserer Wahl für unsere Handelsstrategie verwenden. Wir haben uns für dieses Modell entschieden, weil sein Fehlerniveau genauso gut ist wie das jedes anderen Modells, das wir hätten wählen können, und weil seine Varianz außerdem gering ist. Das lineare Modell ist also weniger anpassungsbedürftig und im Laufe der Zeit eher stabil.
Aufbau der Strategie
Wir sind nun bereit, alles, was wir in den vorherigen Abschnitten besprochen haben, in eine robuste Handelsstrategie unter Verwendung der MetaTrader 5 Library für Python umzusetzen.Bei jedem Schritt werden Erklärungen gegeben, um sicherzustellen, dass der gesamte Code leicht zu verstehen ist.
Zuerst importieren wir die Pakete, die wir benötigen.
from fredapi import Fred import MetaTrader5 as mt5 import pandas as pd import numpy as np import time from datetime import datetime import matplotlib.pyplot as plt
Mit dem fredapi-Paket können wir programmatisch Daten aus der FRED-Datenbank abrufen. Bevor Sie die Bibliothek nutzen können, müssen Sie jedoch einen API-Schlüssel erstellen. Die Erstellung von API-Schlüsseln ist kostenlos, aber Sie können nur einen erhalten, nachdem Sie ein kostenloses Benutzerkonto bei der St. Louis Fed eingerichtet haben.
Jetzt werden wir globale Variablen definieren.
LOGIN = ENTER_YOUR_LOGIN PASSWORD = 'ENTER_YOUR_PASSWORD' SERVER = 'ENTER_YOUR_SERVER' SYMBOL = 'GBPUSD' TIMEFRAME = mt5.TIMEFRAME_D1 DEVIATION = 1000 VOLUME = 0 LOT_MULTIPLE = 1 FRED = Fred(api_key='ENTER_YOUR_API_KEY')
Jetzt melden wir uns bei unserem Handelskonto an.
if mt5.initialize(login=LOGIN,password=PASSWORD,server=SERVER):
print('Logged in successfully')
else:
print('Failed To Log in') Erfolgreich eingeloggt.
Lassen Sie uns unser Handelsvolumen definieren.
for index,symbol in enumerate(mt5.symbols_get()): if symbol.name == SYMBOL: print(f"{symbol.name} has minimum volume: {symbol.volume_min}") VOLUME = symbol.volume_min * LOT_MULTIPLE
GBPUSD hat ein minimales Volumen: 0.01
Definieren wir nun Funktionen, die wir in unserem Programm verwenden werden.
Zunächst benötigen wir eine Funktion, die den aktuellen Marktpreis von unserem MetaTrader 5 Terminal abruft.
def get_prices(): start = datetime(2024,3,20) end = datetime.now() data = pd.DataFrame(mt5.copy_rates_range(SYMBOL,TIMEFRAME,start,end)) data['time'] = pd.to_datetime(data['time'],unit='s') data.set_index('time',inplace=True) return(data.iloc[-1,:])
Als Nächstes benötigen wir eine Funktion zur Abfrage alternativer Daten von der St. Louis Federal Reserve.
def get_alternative_data():
SOFR = FRED.get_series_as_of_date('SOFR',datetime.now())
SOFR = SOFR.iloc[-1,-1]
SOIA = FRED.get_series_as_of_date('IUDSOIA',datetime.now())
SOIA = SOIA.iloc[-1,-1]
return(SOFR,SOIA) Dann brauchen wir eine Funktion zur Vorbereitung der Eingaben für unser Modell.
def get_model_inputs(): LAST_OHLC = get_prices() SOFR , SOIA = get_alternative_data() MODEL_INPUT_DF = pd.DataFrame(index=np.arange(0,1),columns=predictors) MODEL_INPUT_DF['Open'] = LAST_OHLC['open'] MODEL_INPUT_DF['High'] = LAST_OHLC['high'] MODEL_INPUT_DF['Low'] = LAST_OHLC['low'] MODEL_INPUT_DF['Close'] = LAST_OHLC['close'] MODEL_INPUT_DF['IUDSOIA'] = SOIA MODEL_INPUT_DF['SOFR'] = SOFR model_input_array = np.array([[MODEL_INPUT_DF.iloc[0,0],MODEL_INPUT_DF.iloc[0,1],MODEL_INPUT_DF.iloc[0,2],MODEL_INPUT_DF.iloc[0,3],MODEL_INPUT_DF.iloc[0,4],MODEL_INPUT_DF.iloc[0,5]]]) return(model_input_array,MODEL_INPUT_DF.loc[0,'Close'])
Dann brauchen wir eine Funktion, die uns hilft, mit unserem Modell eine Prognose zu erstellen.
def ai_forecast(): model_inputs,current_price = get_model_inputs() prediction = model.predict(model_inputs) return(prediction[0],current_price)
Lassen Sie uns unser Modell trainieren.
training_data = pd.read_csv('C:\\Enter\\Your\\Path\\Here\\Alternative Data.csv')
Unser Modell aufstellen.
from sklearn.linear_model import LinearRegression model = LinearRegression()
Festlegung unserer Prädiktoren und unseres Ziels.
predictors = ['Open','High','Low','Close','IUDSOIA','SOFR'] target = 'Target'
Anpassen unseres Modells.
model.fit(training_data.loc[:,predictors],training_data.loc[:,target])
Damit sind wir beim Herzstück unseres Handelsalgorithmus angelangt:
- Zunächst definieren wir eine Endlosschleife, um unsere Strategie am Laufen zu halten.
- Als Nächstes holen wir aktuelle Marktdaten ab und verwenden sie für eine Prognose.
- Danach werden wir boolesche Flags haben, um die Erwartungen unseres Modells darzustellen. Wenn unser Modell steigende Preise erwartet, ist BUY_STATE wahr, wenn es fallende Preise erwartet, ist SELL_STATE falsch.
- Wenn wir keine offenen Positionen haben, werden wir der Prognose unseres Modells folgen.
- Wenn wir offene Positionen haben, prüfen wir, ob die Prognose unseres Modells mit unserer offenen Position übereinstimmt. Wenn ja, dann schließen wir die Position. Andernfalls können wir die Stelle offen lassen.
- Nach Abschluss aller oben genannten Schritte lassen wir den Algorithmus einen Tag lang schlafen und holen die aktualisierten Daten am nächsten Tag ab.
while True: #Get data on the current state of our terminal and our portfolio positions = mt5.positions_total() forecast , current_price = ai_forecast() BUY_STATE , SELL_STATE = False , False #Interpret the model's forecast if(current_price > forecast): SELL_STATE = True BUY_STATE = False elif(current_price > forecast): SELL_STATE = False BUY_STATE = True print(f"Current price is {current_price} , our forecast is {forecast}") #If we have no open positions let's open them if(positions == 0): print(f"We have {positions} open trade(s)") if(SELL_STATE): print("Opening a sell position") mt5.Sell(SYMBOL,VOLUME) elif(BUY_STATE): print("Opening a buy position") mt5.Buy(SYMBOL,VOLUME) #If we have open positions let's manage them if(positions > 0): print(f"We have {positions} open trade(s)") for pos in mt5.positions_get(): if(pos.type == 1): if(BUY_STATE): print("Closing all sell positions") mt5.Close(SYMBOL) if(pos.type == 0): if(SELL_STATE): print("Closing all buy positions") mt5.Close(SYMBOL) #If we have finished all checks then we can wait for one day before checking our positions again time.sleep(24 * 60 * 60)
Abb. 7: Unser Handel am ersten Tag, an dem wir ihn eröffnet haben.
Abb. 8: Unser Handel am nächsten Tag.
Schlussfolgerung
Alternative Daten haben ein enormes Potenzial, die Art und Weise, wie wir die Finanzmärkte betrachten, zu verändern. Wenn wir die richtigen Datenquellen sorgfältig auswählen, können wir bei den meisten Geschäften, die wir eingehen, auf der richtigen Seite stehen. Die wichtigste Komponente dieser Strategie ist eine zuverlässige Quelle für alternative Daten, andernfalls können Sie genauso gut normale Daten verwenden. Nehmen Sie sich Zeit und recherchieren Sie selbst, ziehen Sie Ihre eigenen Schlüsse und folgen Sie Ihrem Instinkt. Denken Sie daran, dass die Entwicklung von Strategien letztendlich eine Wissenschaft und eine Kunst ist. Wenden Sie daher Ihr logisches Denkvermögen an, wenn Sie auswählen, welche alternativen Datenquellen nützlich wären, und lassen Sie Ihre Phantasie neue Anwendungen und Anwendungsfälle finden, an die die meisten Menschen nicht denken würden, und Sie werden in einer eigenen Liga spielen.
Empfehlungen
Für künftige Leser könnte es sich lohnen, nach weiteren Quellen für alternative Datensätze zu suchen und Techniken des maschinellen Lernens wie die Auswahl der besten Teilmengen einzusetzen, um nützliche Quellen für alternative Daten auszuwählen. Außerdem ist zu bedenken, dass das lineare Modell, das wir in unserer Demonstration verwendet haben, starke Annahmen über den Prozess, der die Daten erzeugt hat, enthält; wenn diese Annahmen verletzt werden, wird sich die Genauigkeit unseres Modells mit der Zeit verschlechtern.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/14441
Die Gruppenmethode der Datenverarbeitung: Implementierung des mehrschichtigen iterativen Algorithmus in MQL5
Einführung in MQL5 (Teil 6): Eine Anleitung für Anfänger zu den Array-Funktionen in MQL5 (II)
MQL5-Assistent - Techniken, die Sie kennen sollten (14): Zeitreihenvorhersage mit mehreren Zielvorgaben durch STF
Datenwissenschaft und maschinelles Lernen (Teil 21): Neuronale Netze entschlüsseln, Optimierungsalgorithmen entmystifiziert
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.