Algorithmischer Handel mit MetaTrader 5 und R für Einsteiger

Einführung

MetaTrader ist ein weltweit anerkannter Spitzenreiter im Bereich der Handelsplattformen. Diese Software ist für ihre branchenübliche Qualität bekannt und wird kostenlos angeboten, sodass sie für ein breites Spektrum von Nutzern zugänglich ist. Infolgedessen hat die MetaTrader-Gemeinschaft Jahr für Jahr ein stetiges Wachstum erlebt. Die Gemeinschaft ist heute so vielfältig wie nie zuvor in ihrer Geschichte und besteht aus Personen mit unterschiedlichem kulturellem Hintergrund und verschiedenen Kenntnissen in Programmiersprachen. Bemerkenswert ist die Tatsache, dass Python neben MetaQuotes Language 5 (der offiziellen Sprache der Plattform) die einzige Programmiersprache ist, die von der MetaTrader-Plattform vollständig unterstützt wird.

Die MetaQuotes-Community heißt alle Mitglieder, die von R zu MetaQuotes wechseln, mit offenen Armen willkommen, unabhängig davon, ob sie aus dem akademischen oder dem wissenschaftlichen Bereich kommen. Trotz der Fortschritte in Python und der ausschließlichen Integration von Python als einzige andere vollständig unterstützte Sprache in das MetaTrader-Terminal müssen Personen, die R beherrschen, ihre Programmierkenntnisse nicht als veraltet betrachten. Dieser Artikel stellt jede Vorstellung von Veralterung in Frage, indem er zeigt, dass es mit Kreativität und ein wenig Einfallsreichtum durchaus möglich ist, einen umfassenden algorithmischen Handelsberater mit R und MetaTrader 5 zu erstellen.

Ausgehend von den Erfahrungen des Autors muss unbedingt darauf hingewiesen werden, dass die in diesem Artikel besprochenen Pakete unvollkommene Interaktionen aufweisen, wenn sie einzeln im MetaTrader 5 Terminal eingesetzt werden. Jedes Paket hat seine ganz eigenen Einschränkungen. Wenn diese Pakete jedoch zusammen eingesetzt werden, kompensieren sie effektiv die Unzulänglichkeiten des jeweils anderen und bilden zusammen einen robusten Rahmen, der die Entwicklung von Handelsalgorithmen mit R und MetaTrader fördert.

Bitte beachten:

1. Berücksichtigung des Betriebssystems:

Diese Demonstration wurde auf einem Windows-Rechner mit Windows 11 OS Build 22621.1848 durchgeführt. Diese Schritte sind nicht auf anderen Betriebssystemen getestet worden.

2. Kompatibilität der Version von R:

In dieser Demonstration wird R Version 4.3.2 verwendet. Es ist zwingend erforderlich, dass die Teilnehmer dieselbe Version von R verwenden, da bestimmte Pakete, die in dieser Präsentation vorgestellt werden, keine Unterstützung für frühere Versionen der Sprache R bieten.

3. Integration von RStudio:

Diese Demonstration lässt sich in RStudio integrieren, einer hochentwickelten integrierten Entwicklungsumgebung zum Schreiben von R-Code. Den Teilnehmern wird empfohlen, RStudio zu nutzen, um eine optimale Codierungserfahrung im Verlauf dieser Demonstration zu erhalten.

Einrichten Ihrer Umgebung

Das Wichtigste zuerst: Richten wir unsere Umgebung ein.

Stellen wir zunächst sicher, dass Sie R Version 4.3.2 auf Ihrem Computer installiert haben. Wenn Sie unsicher sind oder R noch nicht installiert haben, gehen wir die Schritte gemeinsam durch.

Um zu überprüfen, ob R installiert ist, suchen wir das R-Symbol auf Ihrem Desktop. Wenn es dort nicht zu finden ist, können Sie nach „R“ suchen – das sollte das R-Terminal aufrufen, wenn es bereits installiert ist. Wenn Sie R installieren müssen oder eine ältere Version haben, können Sie das Setup aus dem offiziellen R-Repository unter The Comprehensive R Archive Network beziehen. Über diesen Link gelangen Sie immer zur neuesten Version von R, und das ist im Moment die Version 4.3.2. Sobald Sie die Setup-Datei heruntergeladen haben, folgen Sie einfach den Anweisungen, die auf dem Bildschirm erscheinen, und wählen Sie zunächst Ihre Sprache. 

Da Sie nun R installiert haben, sollten Sie die Version überprüfen, die Sie verwenden. Wenn Sie das R-Terminal öffnen, wird die Version oben in der Begrüßungsmeldung angezeigt, sobald Sie eine neue Sitzung starten. Wenn Sie genauere Informationen wünschen, können Sie jederzeit den Befehl „version“ im Terminal verwenden.

Abb. 1: Überprüfen Ihrer R-Version

Lassen Sie uns nun RStudio einrichten. Wenn Sie RStudio nicht installiert haben, können Sie es über diesen Link herunterladen: RStudio Desktop - Posit. Folgen Sie einfach den Anweisungen auf dem Bildschirm, ähnlich wie bei der R-Einrichtung, die wir bereits besprochen haben.

Sobald die Installation abgeschlossen ist, überprüfen wir die Version von R, auf die Ihre Installation von R Studio verweist.

Erstes offenes R-Studio.

Wählen Sie dann „tools“ und „global options“.

Abb. 2: Prüfung, welche Version von R in RStudio ausgeführt wird

Dort sehen Sie die Version von R, die Sie verwenden.

Wenn Sie zwei oder mehr Versionen von R auf Ihrem Rechner installiert haben, die Version 4.3.2, die wir zusammen installiert haben, und die Version, die Sie vielleicht schon vorher hatten, klicken Sie auf „ändern“.

Abb. 3: Prüfung, welche Version von R in RStudio ausgeführt wird

Wählen Sie dort „Choose a specific version of R“ und wählen Sie Version 4.3.2, klicken Sie auf „OK“ und starten Sie RStudio neu, damit die Änderungen wirksam werden. 

Abb. 4: Auswahl einer anderen Version von R

Nachdem Sie RStudio neu gestartet haben, müssen wir einige Abhängigkeiten installieren. 

#Algorithmic Trading With RStudio And MetaTrader 5
#Gamuchirai Zororo Ndawana
#This script will help you get your environment setup and test that everything is working fine
#Sunday 17 December 2023

#Installing Dependencies
install.packages("stringi")             #This package is a dependency for devtools
install.packages("devtools")            #We will use this package to install R packages hosted on github
install.packages("xts")                 #We will use this package to plot data fetched from the MetaTrader 5 Terminal
install.packages("quantmod")            #We will use this package to plot data fetched from the MetaTrader 5 Terminal
install.packages("ttr")                 #We will use this package to calculate technical indicator values 
install.packages("reticulate")          #We will use this package to call Python libraries in R 
devtools::install_github("Kinzel/mt5R") #We will use this open source package to interact with the MetaTrader 5 Terminal

Beginnen wir mit dem Import der ersten Bibliothek, nämlich „reticulate“. Diese Bibliothek ermöglicht es uns, Python-Code in R auszuführen. Wir werden reticulate verwenden, um die MT5 Python Library in einer virtuellen Umgebung zu installieren. Sobald die MT5-Bibliothek installiert ist, können wir reticulate als Brücke zwischen unserer RStudio-Sitzung und der virtuellen Python-Umgebung verwenden. Diese Zwischenverbindung ermöglicht es uns, Befehle an unser MetaTrader 5-Terminal zu senden, was die Ausführung von Geschäften erleichtert.

Wir beginnen mit dem Laden der netzartigen Bibliothek.

#Libraries
#Importing reticulate
library(reticulate)

Als Nächstes erstellen wir eine virtuelle Umgebung mit der Funktion „virtualenv_create()“ in der reticulate-Bibliothek. Diese Funktion benötigt einen String-Parameter, der den Namen unserer virtuellen Umgebung angibt. In der Programmierung bieten virtuelle Umgebungen eine Methode, um isolierte und in sich geschlossene Räume für individuelle Projekte zu schaffen. Der Grundgedanke hinter dem Einsatz virtueller Umgebungen ist die effektive Verwaltung von Abhängigkeiten, die Abschwächung von Konflikten und die Aufrechterhaltung der Reproduzierbarkeit von Projekten. Dies ist besonders wichtig, wenn mehrere Projekte oder Pakete gemeinsame Abhängigkeiten haben, aber unterschiedliche Versionen der gleichen Abhängigkeiten benötigen. 

#Create a virtual environment
virtualenv_create("rstudio-metatrader5")

Sobald die virtuelle Umgebung eingerichtet ist, besteht der nächste Schritt darin, sie zu aktivieren und zu nutzen. Dies wird durch den Einsatz der Funktion „use_virtualenv()“ innerhalb der reticulate-Bibliothek erreicht. Durch die Aktivierung der virtuellen Umgebung wird sichergestellt, dass nachfolgende Python-Operationen im isolierten Kontext dieser Umgebung ausgeführt werden, sodass wir projektspezifische Abhängigkeiten und Konfigurationen verwalten können. 

#Use the virtual environemnt 
use_virtualenv("rstudio-metatrader5")

Lassen Sie uns nun die MetaTrader 5 Python Library mit der Funktion „py_install()“ innerhalb der reticulate Bibliothek installieren. Wir übermitteln der Funktion den Namen der zu installierenden Bibliothek, in diesem Fall „MetaTrader5“.

#Install metatrader5 python library
py_install("MetaTrader5")

Nach der Installation der Bibliothek wird im nächsten Schritt die MetaTrader5-Bibliothek importiert und in einer Variablen namens „MT5“ gespeichert. Dies wird durch die Verwendung der Funktion „import()“ aus der reticulate-Bibliothek erreicht. Die Variable „MT5“ wird in den folgenden Schritten als Schnittstelle für die Interaktion mit der MetaTrader 5-Bibliothek dienen.

#Import MetaTrader 5
MT5 <- import("MetaTrader5")

Bevor Sie fortfahren, vergewissern Sie sich bitte, dass das MetaTrader 5-Terminal nicht in Betrieb ist. Wenn es läuft, schließen Sie es bitte.

Starten wir nun das MetaTrader 5 Terminal direkt aus unserer RStudio-Sitzung. Wir können dies erreichen, indem wir die Funktion „initialize“ aus der MetaTrader5 Python Library aufrufen. Wenn die Initialisierung erfolgreich ist, gibt die Funktion TRUE zurück, was bedeutet, dass das MetaTrader 5 Terminal erfolgreich gestartet wurde.

#Initialize the MetaTrader 5 Terminal
MT5$initialize()

[1] TRUE

Während wir die Möglichkeit haben, auf Kontoinformationen, Terminaldetails und Symbolspezifika zuzugreifen, stoßen wir auf unsere erste Einschränkung: die Unmöglichkeit, sich programmatisch bei einem anderen Konto anzumelden. Das Konto, das bei der Initialisierung des Terminals aktiv ist, wird zum einzigen Konto, auf das der Nutzer Zugriff hat, sofern er es nicht manuell ändert. Es ist zwar möglich, ein Python-Skript zu erstellen, um sich mit der MetaTrader 5 Library bei einem anderen Konto anzumelden und es von R aus mit reticulate auszuführen, aber dieser Artikel geht davon aus, dass die Leser nur über R-Programmierkenntnisse und ein Grundverständnis der MQL5-Programmierung verfügen.

Die nächste Einschränkung besteht darin, dass es nicht möglich ist, historische Preisinformationen mit Hilfe von reticulate abzufragen. Diese Einschränkung kann daher rühren, dass Reticulate im Hintergrund automatisch Datentypen konvertiert, wenn Objekte zwischen R und Python übertragen werden. Folglich scheint es Schwierigkeiten bei der Handhabung des Objekts zu geben, das zurückgegeben wird, wenn historische Kursdaten vom Terminal angefordert werden. Hier greifen wir auf ein zweites Paket zurück, um die Defizite von Retikulat auszugleichen.

#Get account information
account_info <- MT5$account_info()

#Print account information
account_info$company
account_info$balance
account_info$name

#Get terminal information
terminal_info <- MT5$terminal_info()

terminal_info$build
terminal_info$company
terminal_info$name

[1] „Deriv.com Limited“

[1] 868.51

[1] „Gamuchirai Ndawana“

[1] 4094

[1] „MetaQuotes Software Corp.“

[1] „MetaTrader 5“

#Requesting price data
price_data <- MT5$copy_rates_from_pos("Boom 1000 Index",MT5$TIMEFRAME_M1,0,10)

Fehler in py_call_impl(callable, call_args$unnamed, call_args$named) :

SystemError: <built-in-Funktion copy_rates_from_pos> lieferte ein Ergebnis mit einem Ausnahmesatz

Führen Sie „reticulate::py_last_error()“ für Details aus.

Wir werden MT5R einsetzen, um diese Probleme zu lösen. Doch zunächst wollen wir verstehen, wie MT5R unter der Haube funktioniert.

Das MT5R-Paket stellt eine WebSocket-Verbindung zwischen RStudio und dem MetaTrader 5-Terminal her, wodurch ein Vollduplex-Kommunikationskanal entsteht. In einem Vollduplex-System können Daten gleichzeitig gesendet und empfangen werden. Damit dieser Kanal funktioniert, muss das MetaTrader 5-Terminal auf einem bestimmten Port lauschen, den wir für die Übermittlung von Anweisungen verwenden werden. Außerdem muss es mit unserer RStudio-Sitzung über denselben Port kommunizieren. Glücklicherweise enthält MT5R einen in MetaQuotes Language 5 geschriebenen Expert Advisor, der auf unsere Befehle hört. Dieser Berater ist quelloffen und bietet die Flexibilität, bei Bedarf zusätzliche Funktionen einzubauen. Wenn Sie den Quellcode haben möchten, können Sie ihn unter von hier herunterladen. Bitte beachten Sie, dass wir dem Artikel eine angepasste Version des Expert Advisors beigefügt haben. Unsere angepasste Version enthält eine zusätzliche Funktion zum automatischen Setzen von Trailing Stop Losses und Take Profits.

Abb. 5: MT5R-Diagramm

Sobald Sie den Expert Advisor heruntergeladen haben, müssen Sie ihn in denselben Dateien wie Ihre anderen Expertenberater ablegen. Öffnen Sie einfach Ihr MetaTrader 5 Terminal, drücken Sie „Datei“ und dann „Datenordner öffnen“.

Abb. 6: Ihren Datenordner finden

Navigieren Sie dann zu „.\MQL5\experts\“ und legen Sie den Advisor in Ihrem Expertenordner ab. Wenn Sie fertig sind, öffnen Sie das Symbol, mit dem Sie handeln möchten, und platzieren Sie den MT5R Expert Advisor auf dem Chart. Möglicherweise werden Sie von Ihrem Computer gefragt, ob Sie MetaTrader 5 die Erlaubnis erteilen möchten, Netzwerkoperationen auf Ihrem Rechner zu nutzen. Erteilen Sie die Erlaubnis. Sobald das erledigt ist, können wir zu RStudio zurückkehren und mit der Erstellung unseres Handelsalgorithmus fortfahren. 

Öffnen Sie RStudio und importieren Sie die MT5R-, xts- und quantmod-Bibliothek.

#Import the MT5R Library
library(mt5R)
#Import xts to help us plot
library(xts)
#Import quantmod to help us plot
library(quantmod)

Dann prüfen wir, ob unsere Verbindung zum Terminal mit der Funktion Ping() des MT5R-Pakets hergestellt wurde. Die Funktion gibt TRUE zurück, wenn sie mit dem Expert Advisor kommunizieren konnte.

#Check if our connection is established
MT5.Ping()
#Global variables
MARKET_SYMBOL <- "Volatility 75 Index"

[1] TRUE

MT5R löst nicht das Problem der Anmeldung, das wir bereits besprochen haben, aber es löst das Problem der Abfrage von Kursdaten.

Um Kursdaten von unserem MetaTrader 5 Terminal abzufragen, rufen wir die Funktion GetSymbol aus unserer MT5R-Bibliothek auf. Die Funktion erwartet den Namen des Symbols, gefolgt von der Angabe des Zeitrahmens in Minuten, d. h. die täglichen Daten wären 1440, und schließlich die Anzahl der Zeilen. Die Daten werden mit den ältesten Daten am Anfang und dem aktuellen Preis am Ende zurückgegeben. 

Beachten Sie, dass wir den Parameter xts auf true setzen. Dies konvertiert den Datenrahmen in ein R-Zeitreihenobjekt und formatiert die Daten in Ihrem Diagramm automatisch hinter den Kulissen. Außerdem können wir auf diese Weise problemlos Werte für technische Indikatoren in unseren Datenrahmen aufnehmen.

#Request historical price data
price_data <- MT5.GetSymbol(MARKET_SYMBOL, iTF = 1, iRows=5000,xts = TRUE)

Mit der Funktion lineChart() von quantmod können wir die Preisdaten leicht darstellen

#Plotting a line chart
lineChart(price_data, name = MARKET_SYMBOL)

Abb. 7: Plotten von Preisdaten in RStudio

Mit der Funktion addIndicator in quantmod können wir unserem Diagramm auch technische Indikatoren hinzufügen, z. B. einen 60-Perioden-Index der relativen Stärke. 

#We can also add technical indicators to the plot
addRSI(n=60)

Abb. 8: Hinzufügen von technischen Indikatoren zu unserem Diagramm

Verarbeitung Ihrer Daten

Wenn wir den RSI- und den Aroon-Indikator hinzugefügt haben, haben wir sie nur dem Chart hinzugefügt. Um die Werte des technischen Indikators zu unserem Datenrahmen hinzuzufügen, müssen wir den Indikator aus dem quantmod-Paket aufrufen und ihm dann die entsprechenden Spalten übergeben, die für die Berechnungen benötigt werden. Die entsprechenden Spalten sind in der Dokumentation angegeben. In diesem Beispiel fügen wir dem Datenrahmen einen einfachen gleitenden 20-Perioden-Durchschnitt, einen 20-Perioden-Indikator für die relative Stärke und einen 20-Perioden-Indikator für die Average True Range hinzu.

#Add moving average
price_data$SMA_20 <- SMA(price_data$Close,n = 20)
#Add RSI to the dataframe
price_data$RSI_20 <- RSI(price_data$Close,n=20)
#Add ATR to the dataframe
price_data$ATR_20 <- ATR(price_data[,c("High","Low","Close")], n=20)

Sobald dies geschehen ist, werden alle Zeilen mit fehlenden Werten gelöscht.

#Drop missing values
price_data <- na.omit(price_data)

Wir werden eine Funktion namens „next close“ hinzufügen, die den nächsten Schlusskurs enthält. Wenn der nächste Schlusskurs größer als der Schlusskurs ist, ist unser Ziel eins, ansonsten null. Dies geschieht mit Hilfe der ifelse-Funktion in R.

#Next close price
price_data$Next_Close <- lag(price_data$Close,-1)

#Setting up our target
price_data$Target <- ifelse( ( (price_data$Next_Close) > price_data$Close) , 1 , 0)

Danach sind wir bereit, unseren „Train test split“ durchzuführen. Die ersten 4000 Zeilen werden für das Training verwendet, der Rest für die Tests. Bei der Arbeit mit Zeitreihendaten vermeiden wir eine zufällige Aufteilung, um Datenverluste zu vermeiden – eine Situation, in der das Modell unbeabsichtigt aus zukünftigen Informationen lernt, um die Vergangenheit vorherzusagen. Stattdessen legen wir Wert darauf, die natürliche zeitliche Abfolge der Daten beizubehalten. Praktisch bedeutet dies, dass wir die ersten 4000 Zeilen in ihrer chronologischen Reihenfolge auswählen und dann die restlichen Zeilen hinzufügen. Mit diesem Ansatz wird sichergestellt, dass unser Modell aus den Daten der Vergangenheit lernt, um die Zukunft vorherzusagen, und so die bewährten Verfahren der Zeitreihenanalyse beibehält.

#Train test split
train_set <- price_data[1:4000,]
train_y <- price_data[1:4000,c("Target")]

test_set <- price_data[4001:4980,]
test_y <- price_data[4001:4980,c("Target")]

Nachdem wir unsere Daten in Trainings- und Testsätze aufgeteilt haben, besteht der nächste Schritt darin, das ausgewählte Modell zu trainieren. In diesem Fall entscheiden wir uns für die quadratische Diskriminanzanalyse (QDA). QDA ist darauf ausgerichtet, die Unterscheidung zwischen zwei Klassen zu maximieren, um eine effektivere Datenklassifizierung zu ermöglichen. Dies wird erreicht, indem der Abstand zwischen den Mittelwerten der beiden Klassen maximiert und die Abweichung vom Mittelwert innerhalb jeder Klasse minimiert wird. Zur Implementierung von QDA verwenden wir die Bibliothek MASS, die das QDA-Modell enthält. Daher importieren wir die MASS-Bibliothek, um auf das QDA-Modell zuzugreifen und es in unserer Analyse zu verwenden.

#Fitting models
library(MASS)
#Quadratic Discriminant Analysis
#Using OHLC Data
qda  <- qda(Target ~ Open+High+Low+Close,data = train_set)
qda

Aufruf:

qda(Target ~ Open + High + Low + Close, data = train_set)

Vorherige Wahrscheinlichkeiten der Gruppen:

      0       1 

0.49925 0.50075 

Mittelwerte der Gruppen:

      Open     High      Low    Close

0 365424.6 365677.8 365159.9 365420.5

1 365125.4 365384.0 364866.6 365131.4

Aus der Konfusionsmatrix geht hervor, dass unser Modell Aufwärtsbewegungen besser vorhersagt als Abwärtsbewegungen auf dem Markt.

#Evaluating model performance
#Custom Quadratic Discriminant Analysis
qda_predictionts <- predict(qda,test_set)
qda_predictionts <- qda_predictionts$class

#Confusion matrix
table(qda_predictionts,test_y)

Abb. 9: Konfusionsmastrix

Implementierung Ihrer Handelslogik

Damit sind wir beim grundlegenden Kern unseres Handelsalgorithmus angelangt, bei dem das erste Gebot darin besteht, eine Variable mit der Bezeichnung last_trade einzurichten. Diese Variable ist insofern von Bedeutung, als sie die zentrale Funktion der Überwachung des zuletzt eingeleiteten Handels hat. Seine Bedeutung liegt in der Erleichterung der rechtzeitigen Schließung von Positionen, wenn unser Modell eine ungünstige Marktbewegung vorhersagt, die möglicherweise unser gesamtes Marktengagement untergraben könnte. Erinnern wir uns an unser unkompliziertes Kodierungssystem, bei dem ein Wert von 1 einen Kauf (BUY) bedeutet, während ein Wert von 0 einen Verkauf (SELL) anzeigt.

#Keeping track of the last trade
last_trade <- -1

Bei der Operationalisierung unseres Algorithmus ist es unerlässlich, eine Endlosschleife zu initiieren, in der unsere Handelslogik kompliziert verschachtelt ist. Diese Dauerschleife wird durch den Einbau einer Timeout-Funktion erreicht, die die Häufigkeit der Iterationen regelt. In Anlehnung an die Erzeugung neuer Kerzen streben wir synchrone Iterationszyklen an. Die Integration der Funktion Sys.sleep gewährleistet, dass unsere Handelsaktionen dem Rhythmus der minütlichen Marktveränderungen entsprechen.

Unser erster Schritt besteht darin, aktuelle Marktinformationen einzuholen.

Dann geben wir die Daten an unser Modell weiter und erhalten eine Prognose.

Sobald unser Modell eine Prognose erstellt hat, überprüfen wir mit dem MT5-Paket, das wir mit „reticulate“ installiert haben, ob wir offene Positionen haben. Wenn wir keine offenen Positionen haben, eröffnen wir eine Position in der Richtung der Marktprognose und aktualisieren dann unsere Variable last_trade.

Andernfalls, wenn wir eine Position offen haben, prüfen wir, ob unser Modell eine gegnerische Bewegung gegen sie vorhersagt, und wenn das der Fall ist, schließen wir die Position.

Schließlich müssen wir noch ein Timeout hinzufügen, damit unser Algorithmus unsere Position einmal pro Takt überprüft.

while(TRUE){
  #Fetching current market data
  print("Fetching market information")
  data <- MT5.GetSymbol(MARKET_SYMBOL,iTF=1, iRows = 2)
  data <- data[1,]
  
  #Forecasting market move
  qda_forecast <- predict(qda,data)
  qda_forecast <- qda_forecast$class
  print("Model forecast: ")
  print(qda_forecast)
  #Checking if we have no open positions
  current_positions <- MT5$positions_total()
  
  #If we have no open positions, open a position following the model forecast
  if(current_positions == 0){
    print("We have no open positions. Opening a new position")
    
    #A Forecast of 1 means buy
    if(qda_forecast == 1){
      print("Opening Buy Position")
      MT5$Buy(MARKET_SYMBOL,symbol_info$volume_min)
      last_trade <- 1
    }
    #A Forecast of 0 means sell
    if (qda_forecast == 0){
      print("Opening Sell Position")
      MT5$Sell(MARKET_SYMBOL,symbol_info$volume_min)
      last_trade <- 0
    }
  }
  
  else{
      #Are we anticipating a move against our open position?
      if(last_trade != qda_forecast){
        #If we are, let's close our position
        print("Closing open position")
        MT5$Close(MARKET_SYMBOL)
        #Reset last trade
        last_trade <- -1
      }
    
    else{
      #Otherwise everything is expected to be fine
      print("The current position is aligned with the market")
      info <- MT5$account_info()
      print("Current Profit")
      print(info$profit)
    }
    
  }
  #Wait for a new candle to form 
  Sys.sleep(60)
}

Abb. 10: Quadratische Diskriminanzanalyse Modell in R Trading In MetaTrader 5 in Echtzeit.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass dieser Artikel trotz der Herausforderungen bei der Entwicklung eines Echtzeit-Handelsalgorithmus mit R und MetaTrader 5 zeigt, dass die Aufgabe leichter zu bewältigen ist, als es zunächst scheint. Selbst Personen, die mit R noch nicht vertraut sind, können erhebliche Fortschritte erzielen. Die Beschränkungen der einzelnen Pakete werden durch ergänzende Pakete wirksam gemildert, und vor allem werden durch den gewählten Ansatz Abhängigkeiten minimiert. Insgesamt stellt es einen praktikablen und robusten Rahmen dar, der für jeden R-Nutzer zugänglich ist.

Darüber hinaus wurde eine angepasste Version des MT5R-Expertenberaters entwickelt, die selbstständig Stop-Losses und Take-Profits einbaut und so das Handelsmanagement unterstützt. Die Nutzer sind aufgefordert, die Funktionalität nach Bedarf zu erweitern. Ich wünsche Ihnen Frieden, Wohlstand und profitable Geschäfte, bis sich unsere Wege wieder kreuzen.