Deep Learning, Vorhersage und Aufträge mit Python, dem MetaTrader5 Python-Paket und ONNX-Modelldatei

Einführung

Deep Learning ist ein Teilbereich des maschinellen Lernens, der sich auf künstliche neuronale Netze konzentriert, die von der Struktur und Funktion des menschlichen Gehirns inspiriert sind. Dabei werden Modelle so trainiert, dass sie Aufgaben ohne explizite Programmierung, sondern durch das Lernen von Mustern und Darstellungen aus Daten erfüllen. Deep Learning hat aufgrund seiner Fähigkeit, hierarchische Merkmale und Darstellungen automatisch zu erlernen, große Aufmerksamkeit erlangt und ist daher in verschiedenen Bereichen wie der Bild- und Spracherkennung und der Verarbeitung natürlicher Sprache sehr effektiv.

Schlüsselkonzepte des Deep Learning:

• Neuronale Netze: Grundeinheiten des Deep Learning, bestehend aus miteinander verbundenen Knoten oder Neuronen, die in Schichten organisiert sind.
• Tiefe neuronale Netze (Deep Neural Networks, DNNs): Neuronale Netze mit mehreren Schichten, die es ihnen ermöglichen, komplexe Muster zu lernen.
• Training: Der Prozess der Anpassung von Modellparametern anhand von markierten Daten, um die Differenz zwischen vorhergesagten und tatsächlichen Ergebnissen zu minimieren.
• Aktivierungsfunktionen: Funktionen, die auf die Ausgabe der Neuronen angewendet werden, um Nichtlinearität einzuführen, sodass das Modell komplexere Beziehungen lernen kann.
• Backpropagation: Ein Optimierungsalgorithmus, mit dem die Gewichte des Modells auf der Grundlage des Fehlers in seinen Vorhersagen aktualisiert werden.

Python: Python ist eine hochentwickelte, vielseitige Programmiersprache, die für ihre Lesbarkeit und Nutzerfreundlichkeit bekannt ist. Es verfügt über ein umfangreiches Ökosystem von Bibliotheken und Frameworks, die es für verschiedene Anwendungen geeignet machen, darunter Webentwicklung, Data Science, künstliche Intelligenz und mehr.

Hauptmerkmale von Python:

• Lesbarkeit: Die Syntax von Python ist so konzipiert, dass sie lesbar und sauber ist und es Entwicklern leicht macht, Konzepte in weniger Codezeilen auszudrücken.
• Umfangreiche Bibliotheken: Python verfügt über eine Vielzahl von Bibliotheken und Frameworks für verschiedene Anwendungen, wie z. B. NumPy und pandas für die Datenmanipulation, TensorFlow und PyTorch für Deep Learning, Django und Flask für die Webentwicklung und vieles mehr.
• Unterstützung der Gemeinschaft: Python hat eine große und aktive Gemeinschaft von Entwicklern, die zu seiner kontinuierlichen Verbesserung und der Verfügbarkeit zahlreicher Lernressourcen beiträgt.

Python für Deep Learning verwenden: Python ist aufgrund seiner umfangreichen Bibliotheken und Frameworks eine beliebte Sprache für Deep Learning. Zwei wichtige Bibliotheken für Deep Learning in Python sind TensorFlow und PyTorch. Diese Bibliotheken bieten High-Level-Abstraktionen für den Aufbau und das Training neuronaler Netze und machen sie sowohl für Anfänger als auch für erfahrene Praktiker zugänglich.

Zusammenfassend lässt sich sagen, dass Deep Learning ein leistungsstarker Ansatz im Bereich des maschinellen Lernens ist und dass Python eine hervorragende Programmiersprache für die Implementierung von Deep Learning-Modellen und -Lösungen ist. Die Kombination von Python und Deep Learning hat zu Fortschritten in verschiedenen Bereichen geführt und komplexe Aufgaben leichter zugänglich und automatisierbar gemacht.

Bestellung mit Python und MQL5-Paket: Es scheint, dass Sie daran interessiert sind, Python mit dem MQL5-Paket zur Bearbeitung von Handelsaufträgen zu kombinieren. MQL5 ist eine spezialisierte Sprache, die für den algorithmischen Handel auf der Plattform MetaTrader 5 (MT5) entwickelt wurde. Hier ist ein allgemeiner Überblick darüber, wie Sie die Integration von Python mit MQL5 für den Handel angehen könnten:

• Python-Skript für Deep Learning: Entwickeln wir ein Python-Skript mit einer Deep-Learning-Bibliothek (z. B. TensorFlow, PyTorch), um ein Modell für Ihre spezifische Handelsstrategie zu erstellen und zu trainieren. Dieses Skript übernimmt die Analyse und Entscheidungsfindung auf der Grundlage Ihres Deep-Learning-Modells.

• Kommunikation zwischen Python und MQL5: Stellen wir eine Kommunikationsbrücke zwischen Ihrem Python-Skript und der MetaTrader 5-Plattform her. Dies kann mit verschiedenen Methoden geschehen, z. B. über Sockets, REST-APIs oder andere Kommunikationsprotokolle. Das Ziel ist es, unser Python-Skript in die Lage zu versetzen, Handelssignale oder Aufträge an das MetaTrader-Terminal zu senden.

• Ausführung von Aufträgen in MQL5: Implementieren wir in unserem MQL5-Skript oder Expert Advisor die Logik, um Signale vom Python-Skript zu empfangen und entsprechende Kauf-/Verkaufsaufträge auf der MetaTrader 5-Plattform auszuführen. Dabei werden die von der Sprache MQL5 bereitgestellten Handelsfunktionen genutzt.

ONNX

ONNX oder Open Neural Network Exchange, ist ein quelloffenes Format, das die Interoperabilität von Modellen der künstlichen Intelligenz (KI) zwischen verschiedenen Frameworks erleichtern soll. ONNX wurde von Microsoft und Facebook entwickelt und unterstützt und ermöglicht es Nutzern, Modelle mit einem Framework zu trainieren und sie mit einem anderen einzusetzen.

Der Hauptvorteil von ONNX ist seine Fähigkeit, als Zwischenformat zwischen verschiedenen Deep-Learning-Frameworks wie TensorFlow, PyTorch und anderen zu dienen. Diese Austauschbarkeit vereinfacht den Prozess der Integration von Modellen des maschinellen Lernens in verschiedene Anwendungen, Umgebungen und Plattformen.

Im Kontext von MQL5 (MetaQuotes Language 5) beinhaltet die Integration von ONNX-Modellen die Konvertierung eines trainierten maschinellen Lernmodells in das ONNX-Format. Sobald das Modell im ONNX-Format vorliegt, kann es in MQL5-Skripte oder Expert Advisors geladen werden, was die Nutzung fortschrittlicher maschineller Lernfunktionen für algorithmische Handelsstrategien innerhalb der MetaTrader 5-Plattform ermöglicht.

Kurze Einführung in das, was gezeigt werden soll.

Im nächsten Artikel werden wir uns mit der faszinierenden Welt des Deep Learning für den automatisierten Handel befassen. Der Schwerpunkt liegt auf einem Programm für den automatischen Handel, der fortschrittliche Deep-Learning-Techniken nutzt. Wir werden die Feinheiten der Prüfung der Leistung des Modells anhand von Schlüsselkennzahlen wie dem mittleren absoluten Fehler (MAE), dem mittleren quadratischen Fehler (MSE) und dem R-Quadrat (R2) untersuchen. Diese Untersuchung zielt darauf ab, Einblicke in die Effektivität des Deep-Learning-Modells im Kontext des algorithmischen Handels zu geben und seine Vorhersagegenauigkeit und allgemeine Robustheit zu beleuchten. Begleiten Sie uns auf dieser Reise und entdecken wir die Schnittmenge aus Deep Learning, automatisiertem Handel und umfassenden Leistungstests.

Außerdem werden wir uns mit der Umwandlung des Python-Skripts (.py) in eine ausführbare Datei befassen, um ein umfassendes und nutzerfreundliches Paket zu erhalten. Dieser schrittweise Leitfaden bietet detaillierte Einblicke und lässt nichts unversucht, um ein gründliches Verständnis des gesamten Prozesses zu gewährleisten. Am Ende des Artikels werden wir nicht nur ein tiefes Verständnis für die Implementierung von Deep Learning im automatisierten Handel haben, sondern auch das praktische Wissen, wie wir unsere Lösung in ein praktisches, ausführbares Format verpacken können. Bleiben Sie dran für eine ausführliche Anleitung, sie wird uns nahtlos von der Programmierung bis zu einem voll funktionsfähigen, ausführbaren Programm führen und Ihre Erfahrung sowohl lehrreich als auch praktisch machen.

Als letzten Schritt in diesem Artikel werde ich ein Skript erstellen, das die Ausgabe im ONNX-Format erzeugt. Dieses Skript wird dazu beitragen, das ONNX-Modell mit Hilfe eines Expert Advisors (EA) in MetaTrader 5 (MT5) einzubinden. Dieser Prozess verbessert die Anpassungsfähigkeit und die Integration von maschinellen Lernfähigkeiten in die MT5-Plattform und erleichtert die Entwicklung von anspruchsvolleren und effizienteren algorithmischen Handelsstrategien.

Bevor wir mit der Codierung beginnen

Unser Ziel ist die Entwicklung eines Python-Bots, der einen zweistufigen Prozess durchläuft: Zunächst analysiert er die verfügbaren Daten mit Hilfe von Deep Learning und führt anschließend die Handelsaufträge aus. Da der MT5 das Herunterladen einer großen Menge von Tickdaten ermöglicht, besteht unsere Strategie darin, diese Daten zu erfassen und in Kursinformationen umzuwandeln. Bei der Umrechnungsmethode wird der Durchschnitt zwischen den Tick-Werten gebildet, sodass wir eine handlichere Darstellung der Marktpreise für die weitere Analyse und Entscheidungsfindung in unserem Bot erstellen können.

Bevor wir jedoch fortfahren, müssen wir Python verwenden, und für eine bequeme Python-Einrichtung wird empfohlen, Anaconda herunterzuladen und zu installieren. Darüber hinaus wird durch die Installation von Visual Studio Code eine nutzerfreundliche Umgebung für die Skripterstellung geschaffen.

Sobald Sie Anaconda und Visual Studio Code installiert haben, ist der nächste Schritt die Installation einiger Pakete mit pip in Visual Studio Code.

Sie können dies tun, indem Sie das integrierte Terminal in Visual Studio Code öffnen und die folgenden Befehle verwenden (wenn Sie Conda/Anaconda verwenden, führen Sie diese Befehle in Anaconda Prompt aus):

pip install [package1] [package2] ...

Ersetzen Sie [package1] , [package2] usw. durch die Namen der Python-Pakete, die Sie für Ihr Projekt benötigen. Dadurch wird sichergestellt, dass Ihre Umgebung mit den notwendigen Tools und Bibliotheken ausgestattet ist, um mit der Entwicklung Ihres Python-Bots fortzufahren.

Pakete

Sie müssen spezielle Pakete für eine Python-Umgebung installieren, einschließlich MetaTrader 5, TensorFlow und andere Bibliotheken, die mit Anaconda geliefert werden. Hier finden Sie eine allgemeine Anleitung zur Installation dieser Bibliotheken:

1. MetaTrader 5: MetaTrader 5 (MT5) ist eine Handelsplattform. Leider verfügt MetaTrader 5 seit meinem letzten Wissensupdate im Januar 2022 nicht mehr über eine direkte Python-API in der offiziellen Distribution. Es können jedoch einige Bibliotheken oder Wrapper von Drittanbietern existieren. Bitte informieren Sie sich in der offiziellen MetaTrader 5-Dokumentation oder in den einschlägigen Community-Foren über die neuesten Informationen.   

   pip install MetaTrader5

2. TensorFlow: TensorFlow ist eine beliebte Bibliothek für maschinelles Lernen. Sie können es mit dem folgenden Pip-Befehl in Ihrem Terminal oder der Eingabeaufforderung installieren:

   pip install tensorflow

Lasst uns mit der Codierung beginnen

Wenn Sie die erforderlichen Bibliotheken erfolgreich installiert haben, können Sie im nächsten Schritt mit dem Schreiben Ihres Python-Codes beginnen. Zu diesem Zweck müssen Sie die installierten Bibliotheken importieren. In Python verwenden Sie die import-Anweisung, um die Funktionalität einer Bibliothek in Ihren Code einzubinden.

import MetaTrader5 as mt5
from MetaTrader5 import *
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.regularizers import l2
from sklearn.model_selection import KFold

from MetaTrader5 import *

Diese Zeile importiert alle Funktionen und Klassen aus der MetaTrader5-Bibliothek. Die Verwendung von * (Wildcard) bedeutet, dass Sie alles importieren, obwohl von dieser Praxis aufgrund möglicher Namensraumkonflikte generell abgeraten wird.

import numpy as np

Diese Zeile importiert die NumPy-Bibliothek und gibt ihr den Alias np. NumPy wird häufig für numerische Operationen in Python verwendet.

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

Diese Zeilen importieren bestimmte Funktionen/Klassen aus der Bibliothek scikit-learn. Es enthält Dienstprogramme für die Datenvorverarbeitung, die Modellbewertung und die Modellauswahl.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.regularizers import l2

Diese Zeilen importieren Komponenten aus der TensorFlow-Bibliothek, die üblicherweise für Deep Learning verwendet wird. Es bringt das sequenzielle Modell, dichte Schichten und L2-Regularisierung ein.

from sklearn.model_selection import KFold

Diese Zeile importiert die KFold-Klasse aus scikit-learn, die häufig zur Kreuzvalidierung beim maschinellen Lernen verwendet wird.

Zusammenfassend lässt sich sagen, dass Ihr Skript darauf vorbereitet ist, die MetaTrader5-Bibliothek für Finanzdaten, NumPy für numerische Operationen, scikit-learn für maschinelle Lernprogramme und TensorFlow für Deep Learning zu verwenden. Es scheint, als würden Sie eine Umgebung für die Analyse von Finanzdaten einrichten und möglicherweise ein maschinelles Lernmodell für Finanzprognosen erstellen. Stellen Sie sicher, dass Sie diese Bibliotheken in Ihrer Python-Umgebung mit dem entsprechenden Paketmanager (z. B. pip oder conda) installiert haben.

Herunterladen von Daten

Um Ticks herunterzuladen, müssen wir uns zunächst mit dem Datenanbieter (mt5) verbinden und von dort aus können wir die benötigten Daten herunterladen. Zu diesem Zweck werden wir das Folgende verwenden:

# You will need to update the values for path, login, pass, and server according to your specific case.
creds = {
    "path": "C:/Program Files/XXX MT5/terminal64.exe",
    "login": account,
    "pass": clave_secreta,
    "server": server_account,
    "timeout": 60000,
    "portable": False
}
# We launch the MT5 platform and connect to the server with our username and password.
if mt5.initialize(path=creds['path'],
                  login=creds['login'],
                  password=creds['pass'],
                  server=creds['server'],
                  timeout=creds['timeout'],
                  portable=creds['portable']):
    
    print("Plataform MT5 launched correctly")
else:
    print(f"There has been a problem with initialization: {mt5.last_error()}")

Sobald dies geschehen ist, laden wir die Daten, die für das betreffende Symbol von Interesse sind, in Form von Ticks herunter.

rates = rates.drop(index=rates.index)
rates = mt5.copy_ticks_from(symbol, utc_from, 1000000000, mt5.COPY_TICKS_ALL)

Dieser Code löscht zunächst alle vorhandenen Daten im DataFrame „rates“ und holt dann die Tickdaten für ein bestimmtes Symbol und einen bestimmten Zeitbereich mit der Funktion copy_ticks_from aus der MetaTrader 5-Bibliothek.

Da wir die Daten in einem Pandas DataFrame haben wollen (der häufig zusammen mit NumPy verwendet wird), um sie in Python besser bearbeiten zu können, werden wir die Daten in einen Pandas DataFrame übertragen.

rates_frame=pd.DataFrame()
# Empty DataFrame
rates_frame = rates_frame.drop(index=rates_frame.index)
rates_frame = pd.DataFrame(rates)

Dieser Code initialisiert einen leeren Pandas DataFrame namens rates_frame, löscht alle vorhandenen Daten darin und füllt ihn dann mit den Daten aus der Variablen rates.

Zur Vereinfachung addieren und dividieren wir die Geld- und Briefwerte in den Daten durch zwei. Auf diese Weise erhalten wir den Durchschnittswert, der unser Input für das Deep Learning sein wird.

rates_frame['time']=pd.to_datetime(rates_frame['time'], unit='s')
rates_frame['close']=(rates_frame['ask']+rates_frame['bid'])/2

Dieser Code konvertiert die Spalte „time“ in das Datetime-Format mit der Einheit Sekunden und berechnet den Durchschnitt der Werte „ask“ und „bid“, wobei das Ergebnis einer neuen Spalte namens „close“ im DataFrame „rates_frame“ zugewiesen wird.

Die Wahl der Eingabedaten für Deep Learning in Finanzanwendungen, z. B. für die Vorhersage von Kursbewegungen, hängt von verschiedenen Faktoren ab, und es gibt keine Einheitslösung für alle. Es gibt jedoch einige Überlegungen und allgemeine Leitlinien, die zu beachten sind:

Rohdaten vs. Abgeleitete Merkmale (Oszillatoren und Indikatoren):

1. Rohdaten:

• Vorteile:
  • Behält alle verfügbaren Informationen ohne zusätzliche Annahmen bei.
  • Ermöglicht dem neuronalen Netz das Lernen von Mustern direkt aus der Roheingabe.
• Bedenken:
  • Könnte Rauschen oder irrelevante Informationen enthalten.
  • Möglicherweise sind weitere Datenvorverarbeitungen erforderlich.

2. Abgeleitete Merkmale (Oszillatoren und Indikatoren):

• Vorteile:
  • Mit Hilfe von Feature-Engineering kann die spezifische Marktdynamik erfasst werden.
  • Kann eine besser strukturierte Darstellung von Daten bieten.
• Bedenken:
  • Es werden Annahmen darüber getroffen, welche Merkmale relevant sind.
  • Die Wirksamkeit hängt von den gewählten Indikatoren und ihren Parametern ab.

Bewährte Praktiken und Überlegungen:

1. Normalisierung der Daten:

• Wir skalieren die Daten auf einen einheitlichen Bereich (z. B. zwischen 0 und 1), um die Konvergenz während des Trainings zu verbessern.

2. Länge der Sequenz:

• Bei Zeitreihendaten ist die Sequenzlänge von Bedeutung. Experimentieren Sie mit verschiedenen Längen, um den optimalen Kompromiss zwischen der Erfassung relevanter Muster und der Effizienz der Berechnung zu finden.

3. Zeitliche Aspekte:

• Erwägen Sie die Einbeziehung zeitlicher Aspekte, wie z. B. verzögerte Werte oder gleitende Fenster, um zeitliche Abhängigkeiten zu erfassen.

4. Auswahl der Merkmale:

• Experimentieren Sie mit verschiedenen Untergruppen von Merkmalen, um herauszufinden, welche für Ihre spezifische Aufgabe am informativsten sind.

5. Modell der Architektur:

• Passen Sie die Architektur des neuronalen Netzes an die Art Ihrer Eingabedaten an. Rekurrente neuronale Netze (RNNs) und Netze mit langem Kurzzeitgedächtnis (Long Short-Term Memory, LSTMs) sind für sequentielle Daten geeignet.

6. Regulierung:

• Verwenden Sie Regularisierungstechniken (z. B. Dropout), um eine Überanpassung zu verhindern, insbesondere bei hochdimensionalen Daten.

7. Abstimmung der Hyperparameter:

• Experimentieren Sie mit verschiedenen Hyperparametereinstellungen, um die optimale Konfiguration für Ihr Modell zu finden.

In der Praxis ist es oft von Vorteil, verschiedene Ansätze empirisch zu vergleichen. Einige Aufgaben können von der Einfachheit der Rohdaten profitieren, während andere durch gut ausgearbeitete abgeleitete Merkmale an Leistung gewinnen können. Es ist wichtig, ein Gleichgewicht zwischen der Bereitstellung ausreichender Informationen für das Modell und der Vermeidung von Rauschen oder irrelevanten Details zu finden. Außerdem sollte der gewählte Ansatz regelmäßig überprüft werden, da sich die Marktdynamik im Laufe der Zeit ändern kann.

Verschiebung von Daten

Wir haben jetzt die Daten in einem Pandas DataFrame und können sie an Deep Learning senden, um sie als Eingabe zu verarbeiten. Es gibt bereits viele interessante Artikel über Deep Learning in MQL5, daher werde ich nicht weiter darauf eingehen. Ich werde direkt auf den praktischen Aspekt in Python eingehen. Aber bevor wir die Daten an TensorFlow senden, damit es seine Magie entfalten kann, brauchen wir eine Eingabe für die Zeitverschiebung, die wir auf die Daten für die Vorhersage anwenden werden (die verschobene Zeit wird die Zeit sein, die wir vorhersagen wollen). Deshalb haben wir den folgenden Code.

Das Verschieben eines DataFrame im Kontext des Deep Learning, insbesondere bei der Zeitreihenprognose, wird üblicherweise durchgeführt, um Sequenzen von Eingabe- und Zielvariablen zu erstellen. Hier sind die Gründe, warum ein Verschieben im Zusammenhang mit Deep Learning für die Zeitreihenvorhersage verwendet wird:

1. Zeitliche Abhängigkeiten: Deep-Learning-Modelle wie rekurrente neuronale Netze (RNNs) oder Netze mit langem Kurzzeitgedächtnis (long short-term memory, LSTMs) können zeitliche Abhängigkeiten in sequentiellen Daten erfassen. Durch die Verschiebung des Datenrahmens können Sie Sequenzen erstellen, bei denen jede Eingabesequenz einem Segment vergangener Daten entspricht und die entsprechende Zielsequenz die zukünftigen Daten darstellt.

2. Sequentielles Lernen: Deep-Learning-Modelle können Muster und Abhängigkeiten in sequentiellen Daten effektiv erkennen. Durch das Verschieben des DataFrame stellen wir sicher, dass die Eingabe- und Zielsequenzen zeitlich übereinstimmen, sodass das Modell aus dem historischen Kontext lernen und Vorhersagen auf der Grundlage dieses Kontexts treffen kann.

3. Training von Input-Output-Paaren: Das Verschieben hilft bei der Erstellung von Trainingsbeispielen für das Deep-Learning-Modell. Jede Zeile im verschobenen DataFrame kann als Input-Output-Paar betrachtet werden, wobei der Input eine Folge von Beobachtungen aus der Vergangenheit und der Output die Zielvariable ist, die in der Zukunft vorhergesagt werden soll.

number_of_rows= seconds
empty_rows = pd.DataFrame(np.nan, index=range(number_of_rows), columns=df.columns)
df = df._append(empty_rows, ignore_index=True)
df['target'] = df['close'].shift(-seconds)
print("df modified",df)

• number_of_rows ist eine Variable, die die Anzahl der Sekunden angibt.
• empty_rows erzeugt einen neuen DataFrame mit NaN-Werten, der die gleichen Spalten wie der ursprüngliche DataFrame (df) enthält.
• df.append(empty_rows, ignore_index=True) fügt die leeren Zeilen an den ursprünglichen DataFrame (df) an, wobei der Index ignoriert wird, um einen kontinuierlichen Index zu gewährleisten.
• df['target'] = df['close'].shift(-seconds) erzeugt eine neue Spalte „target“, die die „close“-Werte um einen negativen Wert der angegebenen Anzahl von Sekunden verschoben enthält. Dies wird häufig bei der Aufbereitung von Zeitreihendaten für die prädiktive Modellierung gemacht.

Jetzt müssen wir die Daten nur noch bereinigen, damit wir sie als Input für TensorFlow verwenden können.

# Drop NaN values
df=df.dropna()

Das Ergebnis ist ein modifizierter DataFrame ( df ) mit zusätzlichen Zeilen, die mit NaN-Werten gefüllt sind, und einer neuen „Ziel“-Spalte für zeitlich verschobene „Close“-Werte.

Tiefes Lernen

Verwendung von TensorFlow und Keras zum Aufbau und Training eines neuronalen Netzwerks für die Vorhersage von Zeitreihen.

# Split the data into features (X) and target variable (y)
X=[]
y=[]
X = df2[['close']]
y = df2['target']

# Split the data into training and testing sets
X_train=[]
X_test=[]
y_train=[]
y_test=[]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

# Standardize the features
X_train_scaled=[]
X_test_scaled=[]
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Build a neural network model
model=None
model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(X_train.shape[1],), kernel_regularizer=l2(k_reg)))
model.add(Dense(256, activation='relu', kernel_regularizer=l2(k_reg)))
model.add(Dense(128, activation='relu', kernel_regularizer=l2(k_reg)))
model.add(Dense(64, activation='relu', kernel_regularizer=l2(k_reg)))
model.add(Dense(1, activation='linear'))

# Compile the model[]
model.compile(optimizer='adam', loss='mean_squared_error')

# Train the model
model.fit(X_train_scaled, y_train, epochs=int(epoch), batch_size=256, validation_split=0.2, verbose=1)

# Use the model to predict the next 4 instances
X_predict=[]
X_predict_scaled=[]

predictions = pd.DataFrame()
predictions=[]
# Empty DataFrame
#predictions = predictions.drop(index=predictions.index)
X_predict = df2.tail(segundos)[['close']]
X_predict_scaled = scaler.transform(X_predict)
predictions = model.predict(X_predict_scaled)

# Print actual and predicted values for the next 
    n  instances
print("Actual Value for the Last Instances:")
print(df.tail(1)['close'].values)

print("\nPredicted Value for the Next Instances:")
print(predictions[:, 0])
predictions=pd.DataFrame(predictions)

Vorbereitung und Training eines neuronalen Netzes unter Verwendung historischer Finanzdaten zur Vorhersage zukünftiger Werte. Es verwendet die TensorFlow- und Keras-Bibliotheken für die Erstellung und das Training des Modells. Die Vorhersagen werden dann auf der Grundlage des trainierten Modells für die nächsten Instanzen gedruckt.

Erläuterung:

• Das Modell wird als sequentielles Modell initialisiert, d.h. es ist ein linearer Stapel von Schichten.

• Die dichten Schichten stellen vollständig verbundene Schichten im neuronalen Netz dar. Zu den Parametern gehören die Anzahl der Neuronen (Einheiten), die Aktivierungsfunktion, die Eingabeform (gilt nur für die erste Schicht) und die Kernel-Regularisierung (in diesem Fall die L2-Regularisierung mit einer durch k_reg festgelegten Stärke).

• activation='relu' impliziert die Aktivierungsfunktion Rectified Linear Unit (ReLU), die üblicherweise in versteckten Schichten verwendet wird.

• Die letzte Schicht besteht aus einem Neuron mit einer linearen Aktivierungsfunktion, die eine Regressionsausgabe angibt. Wäre dies eine Klassifizierungsaufgabe, würde eine andere Aktivierungsfunktion wie „Sigmoid“ oder „Softmax“ verwendet werden.

Bei dieser Architektur handelt es sich um ein neuronales Feedforward-Netz mit mehreren versteckten Schichten für Regressionszwecke. Passen Sie die Parameter und Ebenen auf der Grundlage Ihrer spezifischen Aufgabe und der Merkmale des Datensatzes an.

Vorhersage

Wie gut ist die Annäherung an dieses Modell?

# Calculate and print mean squared error
mse = mean_squared_error(y_test, model.predict(X_test_scaled))
print(f"\nMean Squared Error: {mse}")

# Calculate and print mean absolute error
mae = mean_absolute_error(y_test, model.predict(X_test_scaled))
print(f"\nMean Absolute Error: {mae}")

# Calculate and print R2 Score
r2 = r2_score(y_test, model.predict(X_test_scaled))
print(f"\nR2 Score: {r2}")

Der mitgelieferte Code berechnet und druckt drei Bewertungsmetriken für ein trainiertes Regressionsmodell.

Erläuterung:

• Mittlerer quadratischer Fehler (Mean Squared Error, MSE): Er misst die durchschnittliche quadratische Differenz zwischen den vorhergesagten und den tatsächlichen Werten. Je niedriger der MSE-Wert, desto besser das Modell.

• Mittlerer absoluter Fehler (Mean Absolute Error, MAE): Er misst die durchschnittliche absolute Differenz zwischen den vorhergesagten und den tatsächlichen Werten. Wie bei MSE deuten niedrigere Werte auf eine bessere Modellleistung hin.

• R2 Ergebnis: Er wird auch als Bestimmtheitsmaß bezeichnet und misst den Anteil der Varianz in der abhängigen Variablen, der durch die unabhängige(n) Variable(n) vorhersagbar ist. Ein R2-Wert von 1 bedeutet eine perfekte Anpassung, während ein Wert von 0 darauf hindeutet, dass das Modell nicht besser ist als die Vorhersage des Mittelwerts der Zielvariablen. Negative Werte weisen auf eine schlechte Modellleistung hin.

Diese Metriken geben Aufschluss darüber, wie gut das trainierte Modell in der Testmenge abschneidet.

In diesem Zusammenhang müssen Sie mit der Datenmenge (Eingabeverzögerung) und der Anzahl der Epochen experimentieren. Ich verwende z. B. 900 Tage Daten und 1 Epoche für EURUSD für einen Zeitraum von 2 Stunden (ich werde dies später genauer erklären). Ich erreiche aber auch mit deutlich weniger Daten und mehr Epochen gute Ergebnisse.

Ordnungsrelationen

Jetzt müssen wir nur noch die Zeit messen, die das Skript braucht, um die Daten zurückzugeben. Dadurch können wir auf dem Chart den Startpunkt der Vorhersage für uns markieren (da die Vorhersage einige Zeit früher beginnt, in meinem Fall dauert es beispielsweise etwa 15-20 Minuten). Wir beginnen mit der Eröffnung von Aufträgen, wenn diese Zeit verstrichen ist. Nachdem ich diesen Bot ausgiebig genutzt habe, ist mir außerdem aufgefallen, dass die genauesten Vorhersagen im ersten Quartal der gesamten Schicht gemacht werden. Um die Genauigkeit zu erhöhen, limitiere und markiere ich auf dem Chart und führe die Aufträge in diesem bestimmten Zeitraum aus. Dies lässt sich leicht mit „time.now()“ realisieren. Wir können die Zeit zu diesem Zeitpunkt erfassen und in Sekunden umrechnen, da unsere Vorhersage und die Skala der x-Achse beide in Sekunden angegeben sind. In Anbetracht all dessen markieren wir den Beginn unserer Vorhersage, und die Aufträge werden auf der Grundlage dieses Ausgangspunkts ausgelöst.

Dies ist ein typischer Python-Auftrag für MetaTrader 5 (MT5). Die Funktion „open_trade_sell2“ stellt eine gemeinsame Struktur für die Platzierung eines Verkaufsauftrags auf der MT5-Plattform dar. Sie nutzt die Methode „mt5.order_send“, um eine Handelsanfrage zur Ausführung des Auftrags zu senden. Zu den Parametern gehören die Handelsaktion („Kauf“ oder „Verkauf“), das Symbol, die Losgröße, eine zufällige ganze Zahl (möglicherweise zur Identifizierung der magischen Zahl), der Take-Profit (tp), der Stop-Loss (sl) und die Abweichung.

def open_trade_sell2(action, symbol, lot,random_integer, tp, sl, deviation):
        '''https://www.mql5.com/en/docs/integration/python_metatrader5/mt5ordersend_py
        '''
        # prepare the buy request structure
        symbol_info = get_info(symbol)
        
        if action == 'buy':
            trade_type = mt5.ORDER_TYPE_BUY
            price = mt5.symbol_info_tick(symbol).ask
        elif action =='sell':
            trade_type = mt5.ORDER_TYPE_SELL
            price = mt5.symbol_info_tick(symbol).bid
        point = mt5.symbol_info(symbol).point
        print("el precio mt5 es:", price)

        buy_request = {
            "action": mt5.TRADE_ACTION_DEAL,
            "symbol": symbol,
            "volume": lot,
            "type": trade_type,
            "price": price,
            "sl":sl,
            "tp":tp,
            "deviation": deviation,
            "magic": random_integer,
            "comment": "python open",
            "type_time": mt5.ORDER_TIME_GTC, # good till cancelled
            "type_filling": mt5.ORDER_FILLING_IOC,
        }
        # send a trading request
        result = mt5.order_send(buy_request)        
        return result, buy_request

Diese Funktion ist Teil eines Skripts, das mit der MT5-Plattform interagiert, um Handelsstrategien zu automatisieren. Zu den wichtigsten Schritten gehören die Bestimmung der Geschäftsart, die Abfrage des aktuellen Bid- oder Ask-Kurses, die Vorbereitung einer Struktur für die Handelsanfrage und schließlich die Übermittlung der Handelsanfrage.

Schließende Aufträge

def close_position(position,symbol):
    """This function closes the position it receives as an argument."""
   
    request = {
        'action': mt5.TRADE_ACTION_DEAL,
        'position': position.ticket,
        'magic': position.magic,
        'symbol': symbol,
        'volume': position.volume,
        'deviation': 50,
        'type': mt5.ORDER_TYPE_BUY if position.type == 1 else mt5.ORDER_TYPE_SELL,
        'type_filling': mt5.ORDER_FILLING_FOK,
        'type_time': mt5.ORDER_TIME_GTC,
        'comment': "mi primera orden desde Python"
    }
    return mt5.order_send(request)

# Now, we define a new function that serves to close ALL open positions.
def close_all_positions(symbol):
    """This function closes ALL open positions and handles potential errors."""
   
    positions = mt5.positions_get()
    for position in positions:
        if close_position(position,symbol).retcode == mt5.TRADE_RETCODE_DONE:
            print(f"Position {position.ticket} closed correctly.")
        else:
            print(f"An error occurred while closing the position.{position.ticket}: {mt5.last_error()}")

Wir können die Aufträge auch mit dem EA schließen, den ich für diese Gelegenheit modifiziert habe. In diesem Fall erstellt die .py-Datei ein Dokument und schreibt die Zeit in Minuten, um Aufträge zu schließen (wenn Sie dies verwenden, denken Sie daran, die Datei im Dateiordner Ihres mt5 zu lassen.

#Specify the path for the file and open it in write mode
file_path = "C:/XXX/MetaQuotes/Terminal/XXX/MQL5/Files/python_"+symbol+"_file.txt"
try:
    with open(file_path, "w") as file:
        # Write file parameters
        file.write(str(the_value))
    print(f"File '{file_path}' created.")
except Exception as e:
    print(f"Error creating file: {e}")

Und dies ist der geänderte EA, den ich von diesem ihm erhalten habe (Sie müssen die richtigen Pfade zum Dateiordner hinzufügen):

//+------------------------------------------------------------------+
//|                                               Timer_modified.mq5 |
//|                                                                  |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2021, Vladimir Karputov"
#property link      "https://www.mql5.com/ru/market/product/43516"
#property version   "1.000"

//--- display the window of input parameters when launching the script
#property script_show_inputs

//--- parameters for data reading
input string InpFileName="python_file.txt"; // file name
input string InpDirectoryName="Files"; // directory name
//---
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
//#include <File.mqh>
//---
CPositionInfo  m_position;                   // object of CPositionInfo class
CTrade         m_trade;                      // object of CTrade class
//--- input parameters
input uchar    InpAfterHour   = 0; // After: Hour ... (max 255)
input uchar    InpAfterMinutes= 42; // After: Minutes ... (max 255)
input uchar    InpAfterSeconds= 59; // After: Seconds ... (max 255)
//---
int file_handles;
uchar value_uchar;
long     m_after  = 0;
bool         started=false;     // flag of counter relevance
string str1,str2,str3,str4;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit()
  {
  str1="C:/XXX/MetaQuotes/Terminal/XXXX/MQL5/Files/python_";
  str3="_file.txt";
  str2=Symbol();
  str4=str1+str2+str3;

   // Open file to read
   string file_path = str4;
   file_handles = FileOpen(file_path, FILE_READ|FILE_TXT);
   
   if(file_handles != INVALID_HANDLE)
     {
      PrintFormat("File %s opened correctly", file_path);
      
      // Read uchar value of the file
      if (FileReadInteger(file_handles, INT_VALUE))
        {
         PrintFormat("Uchar value read from file: %u", value_uchar);
         m_after  = 0;
         m_after=value_uchar;
        }
      else
        {
         Print("Error when reading the uchar value from file");
        }

      // Close file after read
      FileClose(file_handles);
     }
   else
     {
      m_after  = 0;
      m_after=InpAfterHour*60*60+InpAfterMinutes*60+InpAfterSeconds;
      PrintFormat("Error when opening file %s, error code = %d", file_path, GetLastError());
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
        {
         if(TimeCurrent()-m_position.Time()>=m_after)
            m_trade.PositionClose(m_position.Ticket()); // close a position
        }
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| called when a Trade event arrives                                |
//+------------------------------------------------------------------+
void OnTrade()
  {
   if(started) SimpleTradeProcessor();   
  }  
 void SimpleTradeProcessor()
  {
  str1="C:/Users/XXX/MetaQuotes/Terminal/XXX/MQL5/Files/python_";
  str3="_file.txt";
  str2=Symbol();
  str4=str1+str2+str3;
     // Open file to read it
   string file_path = str4;
   file_handles = FileOpen(file_path, FILE_READ|FILE_TXT);
   
   if(file_handles != INVALID_HANDLE)
     {
      PrintFormat("File %s is opened correctly", file_path);
      
      // Reads the uchar value from the file
      if (FileReadInteger(file_handles, INT_VALUE))
        {
         PrintFormat("value_uchar read form file: %u", value_uchar);
         m_after  = 0;
         m_after=value_uchar;
        }
      else
        {
         Print("Error while reading the value uchar from file");
        }

      // Closes the file after reading
      FileClose(file_handles);
     }
   else
     {
      m_after  = 0;
      m_after=InpAfterHour*60*60+InpAfterMinutes*60+InpAfterSeconds;
      PrintFormat("Error when opening the fileo %s, Code error = %d", file_path, GetLastError());
     }    
  }

Ich habe zwei verschiedene Arten des Auftragsabschlusses vorgestellt. In Python verwende ich lediglich „time.sleep(t)“, wobei „t“ die Anzahl der Sekunden zwischen dem Zeitpunkt, an dem die Bestellung aufgegeben wurde, und dem Zeitpunkt, an dem ich sie schließen möchte, angibt. Dieser Ansatz ist jedoch nicht sehr praktisch, da er mit Wartezeiten verbunden ist, die für andere Skriptoperationen genutzt werden könnten. Ich überlasse es Ihnen, zu entscheiden, welche Methode Sie für den Abschluss von Aufträgen verwenden möchten.

Wir können mehr Aufträge generieren, indem wir z. B. die Verwendung von „time.sleep()“ zwischen der Platzierung eines Kauf- oder Verkaufsauftrags und dessen Schließung reduzieren. Wie? Wir können den modifizierten Expert Advisor (EA) nutzen, indem wir den Wert der magischen Zahl einbeziehen und ihm erlauben, nur die Order mit der angegebenen magischen Zahl und dem Symbol zu schließen. Auf diese Weise wird das Skript nicht durch den Ruhezustand unterbrochen, sondern kann aktiv bleiben und weiterarbeiten.

Visualisierung

Um dies effektiv zu visualisieren, werden wir ein Diagramm erstellen, um die Trends zu beobachten. Wir markieren die Bereiche der zuverlässigsten Vorhersagen und geben die Maximal- und Minimalwerte innerhalb dieser Bereiche an; am Ende wird das Diagramm gespeichert.

plt.axvline(x=pt_division2, color='gray', linestyle='--', label='75 %')
plt.axvline(x=center, color='grey', linestyle='--', label='50 %')
plt.axvline(x=pt_division3, color='blue', linestyle='--', label='33 %')
plt.axvline(x=pt_division1, color='gray', linestyle='--', label='25 %')
plt.axvline(x=pt_division6, color='blue', linestyle='--', label='16 %')
plt.axvline(x=pt_division10, color='yellow', linestyle='--', label='10 %')
plt.axvline(x=pt_division14, color='blue', linestyle='--', label='7 %')
plt.axvline(x=pt_division20, color='yellow', linestyle='--', label='5 %')
plt.axvline(x=entry_point, color='orange', linestyle='--', label='entrada')
plt.axvline(x=value_25, color='orange', linestyle='--', label='salida 20%')
plt.axvline(x=maximal_index, color='red', linestyle='--', label='maximal') ##### ni idea de porqué no pinta correctamente la linea
plt.axvline(x=manimal_index, color='red', linestyle='--', label='minimal')# lo mismo aquí

plt.plot(dff5.iloc[:, 0], linestyle='-', label='Predicted')

plt.xlabel('Instances')
plt.ylabel('Prediction Price')
plt.legend()
plt.title(f'Predicted {symbol} y quedan en minutos: ' + str(MyParameter))
plt.savefig('Predicted_for_'+str(symbol)+'_quedan_'+str(MyParameter)+'_minutos_desde_'+str(formatted_now2)+'_.png')

Wie funktioniert das Skript?

Wie funktioniert nun dieses Skript? Zunächst werden die Bibliotheken geladen, dann wird der genaue Zeitpunkt für die Verfolgung des aktuellen Stadiums der Vorhersage notiert. Danach initialisiert es MT5, lädt die Daten herunter, verarbeitet sie und liefert die Ergebnisse. Anhand dieser Ergebnisse erstellen wir ein Diagramm und führen Aufträge zu bestimmten Zeitpunkten aus, einschließlich des spezifischen Timings für Auftragsabschlüsse. Außerdem haben Sie die Möglichkeit, die Methode für den Abschluss von Aufträgen zu wählen.

Wenn Sie diesen Vorgang für dasselbe Währungspaar wiederholen möchten, genügt eine einfache Schleife, die es leicht macht, das Programm kontinuierlich laufen zu lassen. Die Sache hat nur einen Haken: Wie bestimmt man die optimalen Inputs? Nun, das ist ganz einfach. Ein Modell mit einem R2 nahe eins und einem MSE und MAE nahe null weist auf gute Annäherungen hin. Seien Sie jedoch vorsichtig mit einer Überanpassung. Sobald Sie die optimalen Eingabewerte ermittelt haben, können Sie MSE, MAE und R2 vernachlässigen, da ihre Berechnungen viel Zeit in Anspruch nehmen und es in diesem Zusammenhang vor allem auf die Schnelligkeit der Ergebnisse ankommt.

Herstellung einer ausführbaren Datei

Wenn wir mit einem Währungspaar beginnen, müssen wir zunächst wissen, ob wir genaue Vorhersagen machen, bevor wir Aufträge erteilen. Da Python ständig weiterentwickelt wird und Sie möglicherweise Bibliotheken aktualisieren müssen, kann es nicht schaden, alles zu verpacken. Auf diese Weise haben Sie ein konsolidiertes Paket, das Sie testen und ausprobieren können.

Hierfür verwenden wir Tkinter und konvertieren es mit auto-py-to-exe in eine ausführbare Datei. Auf diese Weise werden wir keine weiteren Probleme bei der Bestimmung der Eingabedaten haben, und wir können mit der .py-Datei, die für die Ausführung der Aufträge zuständig ist, vorsichtiger umgehen.

Ich zeige Ihnen, wie Sie eine ausführbare Datei für Testzwecke erstellen, wobei Sie die Datei für die Auftragsausführung selbst anpassen können.

Für die ausführbare Datei werde ich Tkinter verwenden, das eine grafische Schnittstelle zur Eingabe der Werte bietet. Denken Sie daran, dass der Dateipfad entweder mit „/“ oder „\“ geschrieben werden sollte. Die Schnittstelle ruft die Genauigkeitswerte des Modells ab und zeigt die Grafik an.

Hier ist der Code für die Nutzeroberfläche (gui_console)

import tkinter as tk
from program_object import execute_program_with
from program_object_without import execute_program_without
import sys

class Aplication:
    def __init__(self, root):
        self.root = root
        self.root.title("DeepLearning Forecast")
        
        # labels and entries
        label1 = tk.Label(root, text="Input account mt5:")
        label1.pack(pady=5)

        self.value1_entry = tk.Entry(root)
        self.value1_entry.pack(pady=5)

        label2 = tk.Label(root, text="Input password:")
        label2.pack(pady=5)

        self.value2_entry = tk.Entry(root)
        self.value2_entry.pack(pady=5)

        label3 = tk.Label(root, text="Input server of mt5:")
        label3.pack(pady=5)

        self.value3_entry = tk.Entry(root)
        self.value3_entry.pack(pady=5)

        label4 = tk.Label(root, text="Input delay in days (for ticks):")
        label4.pack(pady=5)

        self.value4_entry = tk.Entry(root)
        self.value4_entry.pack(pady=5)

        label5 = tk.Label(root, text="Input timeframe 1 (1h),2,4,1d,1w:")
        label5.pack(pady=5)

        self.value5_entry = tk.Entry(root)
        self.value5_entry.pack(pady=5)

        label6 = tk.Label(root, text="Input epochs:")
        label6.pack(pady=5)

        self.value6_entry = tk.Entry(root)
        self.value6_entry.pack(pady=5)

        label7 = tk.Label(root, text="Input symbol:")
        label7.pack(pady=5)

        self.value7_entry = tk.Entry(root)
        self.value7_entry.pack(pady=5)


        label8 = tk.Label(root, text="Input path for mt5:")
        label8.pack(pady=5)

        self.value8_entry = tk.Entry(root)
        self.value8_entry.pack(pady=5)

        # Radio button to select program to execute
        self.opcion_var = tk.StringVar(value="program_object")
        radio_btn_object = tk.Radiobutton(root, text="With r2 Score, MAE & MSE", variable=self.opcion_var, value="program_object")
        radio_btn_object.pack(pady=5)
        radio_btn_object_without = tk.Radiobutton(root, text="Without", variable=self.opcion_var, value="program_object_without")
        radio_btn_object_without.pack(pady=5)

        # Botón start
        boton_execute = tk.Button(root, text="Run Program", command=self.execute_programa)
        boton_execute.pack(pady=10)

        # Botón close
        boton_quit = tk.Button(root, text="Exit", command=root.destroy)
        boton_quit.pack(pady=10)

    def write(self, text):
        # this method y called when sys.stdout.write is used
        self.salida_text.insert(tk.END, text)
    def flush(self):
        pass
    def execute_program(self):
        # Obteined value of the selected option
        selected_program = self.opcion_var.get()

        # Obteined value of inputs
        value1 = self.value1_entry.get()
        value2 = self.value2_entry.get()
        value3 = self.value3_entry.get()
        value4 = self.value4_entry.get()
        value5 = self.value5_entry.get()
        value6 = self.value6_entry.get()
        value7 = self.value7_entry.get()
        value8 = self.value8_entry.get()

                # Redirects stdout & stderr to the console
        sys.stdout = sys.__stdout__
        sys.stderr = sys.__stderr__

        # Calls the function to execute a selected program and pass values as arguments
        if selected_program == "program_object":
            execute_program_with(value1, value2, value3, value4, value5, value6, value7, value8)
        elif selected_program == "program_object_without":
            execute_program_without(value1, value2, value3, value4, value5, value6, value7, value8)
        # Restores stdout to a predeterminate value to no have conflicts
        sys.stdout = self
        sys.stderr = self

if __name__ == "__main__":
    root = tk.Tk()
    app = Aplication(root)
    root.mainloop()

und dies ist der Code, der aufgerufen wird (wo Sie Ihren Code einfügen müssen):

import sys
import MetaTrader5 as mt5
from MetaTrader5 import *
import matplotlib.pyplot as plt
import seaborn as sns  # Import seaborn for residual plot



def main(value1, value2, value3, value4, value5, value6, value7,value8):
    # Now you can use variables value1, value2, value3, value4, value5, value6, value7 en tu programa
    print("Numero de cuenta mt5 en mt5: ", value1)
    print("Password en mt5: ", value2)
    print("Servidor en mt5: ", value3)
    print("Delay dias ticks: ", value4)
    print("Time frame: ", value5)
    print("Epochs: ", value6)
    print("Symbol: ", value7)
    print("Path a mt5: ", value8)
    

def execute_program_with(value1, value2, value3, value4, value5, value6, value7, value8):
    main(value1, value2, value3, value4, value5, value6, value7, value8)

und es endet mit folgendem

if __name__ == "__main__":
    value1, value2, value3, value4, value5, value6, value7 = sys.argv[1:]
    main(value1, value2, value3, value4, value5, value6, value7)

Es gibt zwei Versionen, eine mit den Modellvorhersagen und dem Diagramm, die andere zeigt nur das Diagramm.

Um dies in eine ausführbare Datei umzuwandeln, verwenden wir auto-py-to-exe. Installieren wir zunächst die Bibliothek:

pip install auto-py-to-exe

und wir lassen sie zum Laufen, indem wir einfach im Terminal auto-py-to-exe eingeben.

Vergessen wir nicht, zum Skript gui_consola hinzuzufügen. Wir fügen die Dateien programa_objetivo.py und programa_objetivo_sin.py hinzu. Jetzt ein Klick auf convert py to exe und wir haben es.

Möglicherweise müssen Sie die conda-Umgebung verwenden, schreiben Sie dazu einfach:

conda activate XXX

wobei XXX der Name der Umgebung ist.

Es könnten aber Probleme mit Conda auftreten. Um dies zu beheben, müsste Anaconda in der Systemsteuerung deinstalliert werden. Navigieren Sie zu „Programm deinstallieren“ und installieren Sie Python direkt von der offiziellen Website. Sie können es von hier herunterladen – wählen Sie nur Ihr Betriebssystem aus.

Denken Sie bei der Installation von Python daran, den Pfad zu den Systemvariablen hinzuzufügen. Deaktivieren Sie außerdem die Längenbegrenzung.

Deaktivieren Sie außerdem die Längenbegrenzung. Um die Einrichtung abzuschließen, installieren Sie matplotlib, seaborn und sklearn, indem Sie den folgenden Befehl in Ihrem Terminal oder der Eingabeaufforderung ausführen:

pip install matplotlib

pip install seaborn

pip install scikit-learn

GUI

Der Begriff „Tk GUI“ bezieht sich auf die grafische Nutzeroberfläche (graphical user interface, GUI), die mit dem Tkinter-Toolkit in Python erstellt wird. Tkinter ist ein integriertes Modul in der Python-Standardbibliothek, das die Entwicklung von grafischen Nutzeroberflächen erleichtert.

Und das sieht so aus:

Denken Sie daran, den Pfad für mt5 hinzuzufügen und „\“ durch „/“ zu ersetzen, wie hier:

C:/Programmdateien/XXX MT5/terminal64.exe

GUI

Dies ist mehr oder weniger das, was Sie in der grafischen Nutzeroberfläche sehen werden, wenn Sie es in eine ausführbare Datei verpacken und ausführen.

Die Ergebnisse für den Tester sehen wie folgt aus:

So sieht der Tester aus, und die Werte innerhalb des roten Rechtecks sind die wichtigen Werte. Offensichtlich sind diese Werte nicht gut, und ich sollte nach einem r2-Score nahe 1 und einem MSE und MAE nahe 0 suchen, ich sollte versuchen, mehr Daten und/oder mehr Epochen zu verwenden, und auch den Wert für L2 im Skript ändern (ich verspreche Ihnen, dass Sie eine gute Anpassung bekommen können und Zeit haben, Bestellungen zu machen ... es ist wie ein Spiel.

Verwendete Metriken:

R2 (R-Quadrat), MSE (mittlerer quadratischer Fehler) und MAE (mittlerer absoluter Fehler) sind in der Statistik und beim maschinellen Lernen gängige Messgrößen zur Bewertung der Leistung von Modellen:

1. R2 (R-Quadrat):

   • R2 ist ein statistisches Maß, das den Anteil der Varianz in der abhängigen Variable angibt, der durch die unabhängige(n) Variable(n) vorhersagbar ist.
   • Es handelt sich um eine Skala von 0 bis 1, wobei 0 bedeutet, dass das Modell die Variabilität der abhängigen Variable nicht erklärt, und 1 eine perfekte Erklärung darstellt.

2. MSE (mittlerer quadratischer Fehler):

   • MSE ist eine Metrik, die die durchschnittliche quadratische Differenz zwischen den tatsächlichen und den vorhergesagten Werten berechnet.
   • Größere Fehler werden stärker bestraft als kleinere, was sie empfindlich gegenüber Ausreißern macht.
   • Mathematisch gesehen ist es die Summe der quadrierten Differenzen geteilt durch die Anzahl der Beobachtungen.

3. MAE (mittlerer absoluter Fehler):

   • MAE ist eine Metrik, die die durchschnittliche absolute Differenz zwischen den tatsächlichen und den vorhergesagten Werten berechnet.
   • Im Gegensatz zum MSE werden die Differenzen nicht quadriert, was ihn weniger empfindlich gegenüber Ausreißern macht.
   • Sie ist die Summe der absoluten Differenzen geteilt durch die Anzahl der Beobachtungen.

Diese Metriken werden üblicherweise in der Regressionsanalyse verwendet, um zu beurteilen, wie gut ein Modell in der Lage ist, die Ergebnisvariable vorherzusagen. Im Allgemeinen weisen ein höherer R2-Wert und niedrigere MSE- oder MAE-Werte auf ein leistungsfähigeres Modell hin.

Überanpassung

Überanpassung beim Deep Learning für den Handel bedeutet, dass ein Modell trainiert wird, das bei historischen Daten gut abschneidet, sich aber nicht effektiv auf neue, ungesehene Daten verallgemeinern lässt. Hier sind einige Gefahren, die mit einer Überanpassung im Zusammenhang mit Deep Learning für den Handel verbunden sind:

1. Begrenzte Verallgemeinerung: Ein überangepasstes Modell kann Rauschen oder bestimmte Muster in den historischen Daten erfassen, die nicht der tatsächlichen Marktdynamik entsprechen. Dies kann dazu führen, dass das Modell nur schwer auf neue Marktbedingungen oder unbekannte Daten verallgemeinert werden kann.
2. Schlechte Leistung bei Live-Daten: Da ein überangepasstes Modell im Wesentlichen die historischen Daten speichert, kann es schlecht abschneiden, wenn es mit aktuellen Marktdaten konfrontiert wird. Das Modell könnte ungenaue Vorhersagen machen oder sich nicht an veränderte Markttrends anpassen.
3. Änderungen des Marktregimes: Die Finanzmärkte sind dynamisch, und verschiedene Marktzustände (Hausse, Baisse, Seitwärtsbewegung) können einzigartige Merkmale aufweisen. Ein überangepasstes Modell, das für ein bestimmtes Marktregime trainiert wurde, kann versagen, wenn der Markt einen Regimewechsel erfährt, da es ihm an Anpassungsfähigkeit mangelt.
4. Falsche Signale: Eine Überanpassung kann dazu führen, dass das Modell Rauschen oder Ausreißer in den historischen Daten erfasst, was zu falschen Signalen führt. Diese falschen Signale können Handelsstrategien in die Irre führen und in Live-Handelsszenarien zu finanziellen Verlusten führen.
5. Data Snooping Bias: Die Überanpassung kann durch Datenschnüffelei oder Datenlecks verschlimmert werden. Wenn das Modell während des Trainings versehentlich mit Informationen aus dem Testsatz konfrontiert wird, kann es Muster lernen, die sich nicht gut auf wirklich ungesehene Daten verallgemeinern lassen.
6. Empfindlichkeit der Hyperparameter: Überangepasste Modelle können übermäßig empfindlich auf Hyperparameter reagieren, was die Feinabstimmung für eine robuste Leistung unter verschiedenen Marktbedingungen erschwert.

Um diese Gefahren zu entschärfen, setzen Praktiker des Deep Learning für den Handel häufig Strategien wie Kreuzvalidierung, Regularisierungstechniken und die Einbeziehung von Merkmalen ein, die ein breiteres Verständnis der Marktdynamik darstellen. Darüber hinaus ist eine vorsichtige Herangehensweise erforderlich, wenn die Leistung des Modells anhand historischer Daten interpretiert und seine Wirksamkeit anhand von Datensätzen außerhalb der Stichprobe validiert werden soll. Regelmäßige Überwachung und Umschulung der Modelle sind ebenfalls unerlässlich, um sich an die sich verändernden Marktbedingungen anzupassen.

Kreuzvalidierung beim Deep Learning:

Die Kreuzvalidierung ist ein statistisches Verfahren zur Bewertung der Leistung eines maschinellen Lernmodells. Im Zusammenhang mit Deep Learning beinhaltet die Kreuzvalidierung die Aufteilung des Datensatzes in mehrere Teilmengen oder Foldings. Das Modell wird auf einigen dieser Faltungen trainiert und auf den verbleibenden Faltungen getestet. Dieser Vorgang wird mehrfach wiederholt, wobei in jeder Iteration andere Faltungen für das Training und den Test verwendet werden. Die Leistungskennzahlen werden dann über alle Iterationen gemittelt, um eine solidere Bewertung der Leistung des Modells zu erhalten.

Zu den üblichen Arten der Kreuzvalidierung gehören die k-fache Kreuzvalidierung, bei der der Datensatz in k Falten unterteilt wird und jede Falte genau einmal als Testsatz verwendet wird, und die Leave-One-Out-Kreuzvalidierung, bei der jeder Datenpunkt als eine einzelne Falte behandelt wird.

Die Kreuzvalidierung hilft bei der Beurteilung, wie gut ein Modell auf ungesehene Daten verallgemeinert werden kann, und verringert das Risiko einer Über- oder Unteranpassung.

Kernel Regularizer (kernel_regularizer=l2):

Im Zusammenhang mit Deep Learning und neuronalen Netzen bezieht sich der Begriff Kernel-Regularisierer auf eine Regularisierungstechnik, die auf die Gewichte (oder Kernel) der Schichten des neuronalen Netzes angewendet wird. Der Parameter „kernel_regularizer=l2“ gibt speziell die Verwendung der L2-Regularisierung für die Gewichte an.

Die L2-Regularisierung fügt der Verlustfunktion einen Strafterm hinzu, der proportional zum Quadrat der Gewichte ist. Ziel ist es zu verhindern, dass ein einzelnes Gewicht zu groß wird und den Lernprozess dominiert. Dies trägt dazu bei, eine Überanpassung zu verhindern, indem das Modell davon abgehalten wird, sich zu eng an die Trainingsdaten anzupassen.

Zusammenfassend lässt sich sagen, dass „kernel_regularizer=l2“ eine Regularisierungstechnik ist, die verwendet wird, um die Komplexität eines neuronalen Netzwerks zu kontrollieren, indem große Gewichte bestraft werden, und sie ist eines der Werkzeuge, um Probleme der Überanpassung in Deep-Learning-Modellen anzugehen.

Diagramm

Dieses Diagramm wird dort gespeichert, wo Sie das Skript ausführen.

Die Zahl in der Überschrift gibt die Zeit in Minuten an, die von der ersten orangefarbenen Linie bis zum Ende des Diagramms vergeht.

Sie können das Diagramm nach Ihren Wünschen ändern (z. B. nur den Bereich zwischen den orangefarbenen Linien anzeigen), indem Sie diesen Zeilencode verwenden:

plt.plot(dff5.iloc[punto_entrada, valor_25], linestyle='-', label='Predicted')

Lesen Sie einfach den Code und versuchen Sie, ihn zu verstehen.

Dies ist das erzeugte Diagramm. Die roten Linien zeigen an, wo Kauf-/Verkaufs- und Schließungsaufträge platziert werden sollten. Die orangefarbenen Linien stellen den Bereich dar, in dem das Modell vermutlich zuverlässiger und genauer ist, insbesondere im ersten 20%-Intervall. In diesem Fall habe ich einen 4-Stunden-Zeitrahmen verwendet, sodass das optimale Intervall die erste Stunde ist, die den maximalen und minimalen Punkt für den Ein- und Ausstieg anzeigt. Sobald das Skript das Ende erreicht hat, kehrt es in einer Schleife zurück, und wenn wir die Aufträge hinzufügen, wird es kontinuierlich weiterlaufen. Die übrigen markierten Linien helfen bei der Positionierung auf dem Chart, wenn Sie manuelle Aufträge erteilen.

Der in den Vorhersagen angegebene Preis ist nur ein Richtwert. Wichtig ist, dass Sie wissen, wo das Minimum und das Maximum im Intervall liegen.

Wie man das alles nutzt

Was ich tue, ist:

Zunächst experimentiere ich mit einem Symbol über die grafische Nutzeroberfläche und teste es mit R2, MAE und MSE. Ich durchlaufe verschiedene Werte von Epochen und Tagen der Verzögerung. Zweitens gehe ich, sobald ich vielversprechende Werte für die Vorhersage ermittelt habe, zum Skript über, wobei ich darauf achte, dass eine Überschätzung vermieden wird. Ich automatisiere das Skript zur autonomen Ausführung von Aufträgen und miete einen VPS für die kontinuierliche Auftragsausführung während der Woche. Es ist erwähnenswert, dass bei hohen Fehlern auch ein Parameter eingestellt werden kann. Im Falle von Kryptowährungen könnte man sich beispielsweise für eine L2 von 0,01 anstelle der 0,001 entscheiden, die für Devisen verwendet wird. Durch Versuch und Irrtum können optimale Werte für die Datenmenge (Verzögerungstage) und die Epochen ermittelt werden.

Es ist wichtig zu bedenken, dass die Berechnung von MSE, R2 und MAE etwa eine Epoche in Anspruch nimmt. Daher ist es ratsam, zunächst Experimente durchzuführen. Sobald eine gute Modellannäherung erreicht ist, kann das Modell ohne diese Parameter verwendet werden. In Python wird dies entweder durch Auskommentieren des entsprechenden Codes oder durch Verwendung des Symbols # erreicht.

Ich verwende in diesem Python-Programm eine Schleife. Für den Fall, dass beim Schließen von Aufträgen ein Fehler auftritt (ich habe einen Mechanismus zum Abbrechen der Befehle im Symbol implementiert), verwende ich auch timer.mql5, da ich ein Intervall für die Aufträge festgelegt habe, nämlich eine Stunde. Dadurch wird sichergestellt, dass kein Auftrag länger als eine Stunde offen bleibt.

Schleife

Um den DeepLearningForecast in einer Schleife laufen zu lassen, können wir anstelle eines „while = True“ dies tun (Loop.py):

import time
import subprocess

def execute_program():
    
    subprocess.run(['python', 'DeepLearningForecast.py'])

# Stablish and interval in seconds (for example, 60 seconds)
seconds_interval = 5


while True:
    execute_program()
    print(f"Program executed. Waiting {seconds_interval} seconds")

    # waits the interval before executing the program
    time.sleep(seconds_interval)

Telegramm-Bot

Im MT5 haben wir bereits verschiedene Möglichkeiten, Informationen einzusehen, aber bei diesem Bot bin ich manchmal daran interessiert, zu wissen, ob er genaue Vorhersagen macht und Aufträge korrekt ausführt. Um diese Aktionen zu verfolgen und anschließend die Vorhersagen mit dem tatsächlichen Chart zu vergleichen, sende ich den Chart und die relevanten Informationen an einen Telegram-Bot. Ich werde nun erklären, wie man den Telegram-Bot erstellt und wie man die Daten über Telegram sendet.

Eine Schritt-für-Schritt-Anleitung, um einen Bot auf Telegram zu erstellen und seine Chat-ID und sein Token zu erhalten, um Nachrichten über Anfragen zu senden:

Erstellen Sie einen Bot auf Telegram:

1. Öffnen Sie Telegram und suchen Sie nach „BotFather“:

   • Öffnen Sie Telegram und suchen Sie in der Suchleiste nach „BotFather“.
   • Beginne einen Chat mit BotFather.

2. Erstellen Sie einen neuen Bot:

   • Verwenden Sie den Befehl /newbot, um einen neuen Bot zu erstellen.
   • Folgen Sie den Anweisungen von BotFather, um Ihrem Bot einen Namen und einen Nutzernamen zuzuweisen.
   • Sobald dies geschehen ist, erhalten Sie von BotFather ein Token. Dieses Token ist für die Authentifizierung Ihres Bots erforderlich.

Chat-ID abrufen:

1. Starten Sie einen Chat mit Ihrem Bot:

• Nachdem Sie Ihren Bot erstellt haben, starten Sie einen Chat mit ihm auf Telegram.

2. Besuchen Sie die URL der Bot-API:

   • Öffnen Sie einen Webbrowser und rufen Sie die folgende URL auf. Ersetzen Sie dabei BOT_TOKEN durch das Token Ihres Bots:

   https://api.telegram.org/botBOT_TOKEN/getUpdates

1. Senden Sie eine Nachricht an den Bot:

   • Gehen Sie zurück zu Telegram und senden Sie eine Nachricht an den Bot, mit dem Sie den Chat begonnen haben.

2. Aktualisieren Sie die Browser-Seite:

   • Kehren Sie zu der Browser-Seite zurück, auf der Sie die Bot-API-URL eingegeben haben.
   • Aktualisieren Sie die Seite.

3. Suchen Sie die Chat-ID:

   • Suchen Sie in der JSON-Antwort nach dem Abschnitt, der den Nachrichtenverlauf enthält.
   • Suchen Sie das Objekt, das Ihre kürzlich gesendete Nachricht darstellt.
   • Suchen Sie in diesem Objekt das Chat-Feld, und darin wird das Feld id die Chat-ID sein.

Das Ergebnis wird sein, dass Sie eine Nachricht wie diese erhalten können (um den Überblick über den Bot zu behalten):

Andere Korrekturen

Da mir die Art und Weise, wie die Aufträge geschlossen wurden, nicht gefiel, habe ich das Skript geändert, um die Trends zu nutzen. Ich habe einen einfachen gleitenden Durchschnitt (SMA) hinzugefügt und ihn angewiesen, die Aufträge zu schließen, wenn der Preis den SMA kreuzt.

Um dies zu beheben:

habe ich dies hinzugefügt:

def obtain_sma_pandas(symbol, periodo):
    prices = mt5.copy_rates_from_pos(symbol, mt5.TIMEFRAME_M1, 0, periodo)
    df_sma = pd.DataFrame(prices)
    sma = df_sma['close'].rolling(window=periodo).mean().iloc[-1]
    return sma

und dies:

    action="buy"
    price = mt5.symbol_info_tick(symbol).ask
    period_sma=14
    sma = obtain_sma_pandas(symbol, period_sma)
    while True:
        # Obtener el precio actual y la SMA
        actual_price = price
        sma = obtain_sma_pandas(symbol, period_sma)

        # Si el precio está por debajo de la SMA, cerrar la orden
        if actual_price > sma:
            close_all_position(symbol)
            continue

        # Esperar antes de verificar nuevamente
        time.sleep(10)

Sie können dem Skript auch adx hinzufügen, um damit handeln, wenn es einen Trend gibt:

def calculate_adx(high, low, close, period):

    tr_pos = []
    tr_neg = []

    for i in range(1, len(close)):
        trh = max(high[i] - high[i - 1], 0)
        trl = max(low[i - 1] - low[i], 0)

        if trh > trl:
            tr_pos.append(trh)
            tr_neg.append(0)
        elif trl > trh:
            tr_pos.append(0)
            tr_neg.append(trl)
        else:
            tr_pos.append(0)
            tr_neg.append(0)

    atr = pd.Series(tr_pos).ewm(span=period, adjust=False).mean() + pd.Series(tr_neg).ewm(span=period, adjust=False).mean()
    dx = (pd.Series(tr_pos).ewm(span=period, adjust=False).mean() / atr) * 100
    adx = dx.ewm(span=period, adjust=False).mean()

    return adx.iloc[-1]

ONNX

Mit Hilfe der Erkenntnisse aus dem Artikel „Wie man ONNX-Modelle in MQL5 verwendet“ von MetaQuotes bin ich nun dabei, das Modell in das ONNX-Format zu konvertieren. Gemäß den im selben Artikel enthaltenen Richtlinien werde ich das resultierende ONNX-Modell in den Basis-Expert Advisor (EA) integrieren, um den Handel zu starten. Dieser Ansatz ermöglicht die nahtlose Integration von Modellen des maschinellen Lernens in die MQL5-Umgebung, wodurch die Fähigkeiten des Handelsalgorithmus verbessert werden.

Vor der Formatierung in ONNX ist es notwendig, die Daten herunterzuladen. Zu diesem Zweck verwenden wir das von mir hochgeladene Skript (ticks_to_csv). Speichern Sie es einfach im MQL5 EA-Ordner, öffnen Sie es in der IDE und kompilieren Sie es. Ziehen Sie das Skript anschließend auf einen Chart und lassen Sie es einige Zeit laufen (da es alle Ticks für ein Symbol herunterlädt, kann es eine Weile dauern). Im Journal wird eine Meldung angezeigt, wenn der Vorgang abgeschlossen ist. Als Referenz habe ich es für EUR/USD verwendet, und es hat mehrere Gigabyte belegt.

#property script_show_inputs
#property strict
//--- Requesting 100 million ticks to be sure we receive the entire tick history
input long      getticks=100000000000; // The number of required ticks
string fileName = "ticks_data.csv";
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int     attempts=0;     // Count of attempts
   bool    success=false;  // The flag of a successful copying of ticks
   MqlTick tick_array[];   // Tick receiving array
   MqlTick lasttick;       // To receive last tick data

   SymbolInfoTick(_Symbol,lasttick);
//--- Make 3 attempts to receive ticks
   while(attempts<3)
     {

      //--- Measuring start time before receiving the ticks
      uint start=GetTickCount();
      //--- Requesting the tick history since 1970.01.01 00:00.001 (parameter from=1 ms)
      long received=CopyTicks(_Symbol,tick_array,COPY_TICKS_ALL,1,getticks);

      // Check if ticks were successfully copied
      if(received > 0)
        {
         // Open the CSV file for writing
         int fileHandle = FileOpen(fileName, FILE_WRITE | FILE_CSV);

         // Check if the file was opened successfully
         if(fileHandle != INVALID_HANDLE)
           {
            // Write the CSV header
            FileWrite(fileHandle, "Time,Bid,Ask");

            // Write tick data to the CSV file
            for(long i = 0; i < received; i++)
              {
               string csvLine = StringFormat("%s,%.5f,%.5f", TimeToString(tick_array[i].time), tick_array[i].bid, tick_array[i].ask);
               FileWrite(fileHandle, csvLine);
              }


            // Close the CSV file
            FileClose(fileHandle);

            // Print success message
            Print("Downloaded ", received, " ticks for symbol ", _Symbol, " and period ", Period());
            Print("Ticks data saved to ", fileName);
           }
         else
           {
            // Print an error message if the file could not be opened
            Print("Failed to open the file for writing. Error code: ", GetLastError());
           }
        }
      else
        {
         // Print an error message if no ticks were downloaded
         Print("Failed to download ticks. Error code: ", GetLastError());
        }

      if(received!=-1)
        {
         //--- Showing information about the number of ticks and spent time
         PrintFormat("%s: received %d ticks in %d ms",_Symbol,received,GetTickCount()-start);
         //--- If the tick history is synchronized, the error code is equal to zero
         if(GetLastError()==0)
           {
            success=true;
            break;
           }
         else
            PrintFormat("%s: Ticks are not synchronized yet, %d ticks received for %d ms. Error=%d",
                        _Symbol,received,GetTickCount()-start,_LastError);
        }
      //--- Counting attempts
      attempts++;
      //--- A one-second pause to wait for the end of synchronization of the tick database
      Sleep(1000);
     }
  }

Und aus diesen Daten (CSV) werden wir das benötigte Segment lesen und verwenden, indem wir es in einen DataFrame umwandeln (die Datei DeepLearning_ONNX.py wurde für die letzten 1000 Tage bis heute definiert). Sie können den gesamten Datensatz verwenden, benötigen dafür aber ausreichend RAM.

Sobald wir die Daten heruntergeladen haben, können wir damit beginnen, das ONNX-Modell mit der Datei DeepLearningForecast_ONNX_training.py zu trainieren. (Bitte speichern Sie die Datei in einem Ordner unter dem Ordner File von MQL5.

Damit importiert er die Daten:

rates = pd.read_csv(file_path, encoding='utf-16le')

erstellt ein Modell mit diesem:

onnx_model = tf2onnx.convert.from_keras(model, output_path=output_path)

Schlussfolgerung

Abschließend wurde in diesem Artikel ein umfassender Ansatz für die Entwicklung eines Python-Skripts für den automatisierten Handel mit Deep Learning beschrieben. Wir untersuchten die Integration von MetaTrader 5, die Datenvorverarbeitung, das Modelltraining und die Ausführung von Kauf-/Verkaufsaufträgen. Die Verwendung von Tkinter und auto-py-to-exe zur Erstellung einer ausführbaren Datei mit einer nutzerfreundlichen Oberfläche macht das Skript noch praktischer.

Darüber hinaus wurden Überlegungen zur Auswahl geeigneter Eingabedaten, zur Bewertung der Modellleistung und zur Umsetzung effektiver Strategien für Abschlussaufträge angestellt. Die visuelle Ausgabe des Skripts, die Vorhersagen, verlässliche Bandbreiten und die Platzierung von Aufträgen zeigt, bietet einen klaren und umsetzbaren Überblick sowohl für den automatisierten als auch den manuellen Handel.

Zu guter Letzt haben wir gelernt, wie man alle Ticks für ein Währungspaar importiert. Wir haben Python verwendet, um diese Daten zu lesen, ein ONNX-Modell zu erstellen und (wenn der nächste Artikel interessant ist) das Modell im MT5 mit einem Expert Advisor (EA) auszuführen.

Es ist jedoch wichtig, die dynamische Natur der Finanzmärkte zu betonen, die eine kontinuierliche Überwachung, Anpassung und mögliche Verbesserung des Modells rechtfertigt. Der skizzierte Rahmen dient als solide Grundlage, und die Nutzer sind aufgefordert, ihn auf der Grundlage der sich entwickelnden Marktbedingungen und ihrer spezifischen Handelsziele weiter anzupassen und zu verbessern.

Haftungsausschluss

Haftungsausschluss: Die Wertentwicklung in der Vergangenheit lässt keine Rückschlüsse auf zukünftige Ergebnisse zu. Der Handel mit Kryptowährungen und anderen Finanzinstrumenten birgt Risiken; keine Strategie kann in jedem Szenario Gewinne garantieren. Führen Sie stets gründliche Recherchen durch und lassen Sie sich von Finanzfachleuten beraten, bevor Sie Anlageentscheidungen treffen.