Sentiment-Analyse und Deep Learning für den Handel mit EA und Backtesting mit Python

Einführung

Die Integration von Deep Learning und Sentiment-Analysen in Handelsstrategien in MetaTrader 5 (MQL5) stellt einen hochentwickelten Fortschritt im algorithmischen Handel dar. Deep Learning, ein Teilbereich des maschinellen Lernens, umfasst neuronale Netze mit mehreren Schichten, die aus umfangreichen und komplexen Datensätzen lernen und Vorhersagen treffen können. Die Stimmungsanalyse hingegen ist ein Verfahren zur Verarbeitung natürlicher Sprache (NLP), mit dem die Stimmung oder der emotionale Ton eines Textes ermittelt werden kann. Durch den Einsatz dieser Technologien können Händler ihre Entscheidungsprozesse verbessern und die Handelsergebnisse steigern.

In diesem Artikel werden wir Python in MQL5 integrieren, indem wir eine DLL shell32.dll verwenden, die das ausführt, was wir für Windows benötigen. Durch die Installation von Python und die Ausführung über shell32.dll können wir Python-Skripte aus dem MQL5 Expert Advisor (EA) starten. Es gibt zwei Python-Skripte: eines, um das trainierte ONNX-Modell von TensorFlow auszuführen, und ein anderes Skript, das Bibliotheken verwendet, um Nachrichten aus dem Internet zu holen, die Schlagzeilen zu lesen und die Medienstimmung mithilfe von KI zu quantifizieren. Dies ist eine mögliche Lösung, aber es gibt viele Möglichkeiten und verschiedene Quellen, um die Stimmung einer Aktie oder eines Symbols zu ermitteln. Sobald das Modell und die Stimmung ermittelt sind und beide Werte übereinstimmen, wird der Auftrag vom EA ausgeführt.

Können wir einen Test in Python durchführen, um die Ergebnisse der Kombination von Stimmungsanalyse und Deep Learning zu verstehen? Die Antwort ist ja, und wir werden den Code weiter studieren.

Backtesting der Sentiment-Analyse mit Deep Learning unter Verwendung von Python

Um das Backtesting dieser Strategie durchzuführen, werden wir die folgenden Bibliotheken verwenden. Ich werde meinen anderen Artikel als Ausgangspunkt verwenden. Wie dem auch sei, ich werde auch hier die erforderlichen Erläuterungen geben.

Wir werden die folgenden Bibliotheken verwenden:

import ccxt
import pandas as pd
import numpy as np
import onnx
import onnxruntime as ort
import matplotlib.pyplot as plt
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, mean_absolute_percentage_error
from sklearn.model_selection import TimeSeriesSplit
from sklearn.preprocessing import MinMaxScaler
import requests
from datetime import datetime, timedelta
import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
from newsapi import NewsApiClient

Als Erstes stellen wir sicher, dass nltk aktualisiert ist.

nltk.download('vader_lexicon')

nltk (Natural Language Toolkit) ist eine Bibliothek, die für die Arbeit mit menschlichen Sprachdaten (Text) verwendet wird. Sie bietet nutzerfreundliche Schnittstellen zu über 50 Korpora und lexikalischen Ressourcen wie WordNet, zusammen mit einer Reihe von Textverarbeitungsbibliotheken für Klassifizierung, Tokenisierung, Stemming, Tagging, Parsing und semantische Schlussfolgerungen sowie Wrapper für industrielle NLP-Bibliotheken.

Die Leser müssen das Python-Backtesting-Skript anpassen, um anzugeben, woher sie die Daten, den Nachrichten-Feed und die Daten für die ONNX-Modelle erhalten.

Für die Stimmungsanalyse werden wir Folgendes verwenden:

def get_news_sentiment(symbol, api_key, date):
    try:
        newsapi = NewsApiClient(api_key=api_key)
        
        # Obtener noticias relacionadas con el símbolo para la fecha específica
        end_date = date + timedelta(days=1)
        articles = newsapi.get_everything(q=symbol,
                                          from_param=date.strftime('%Y-%m-%d'),
                                          to=end_date.strftime('%Y-%m-%d'),
                                          language='en',
                                          sort_by='relevancy',
                                          page_size=10)
        
        sia = SentimentIntensityAnalyzer()
        
        sentiments = []
        for article in articles['articles']:
            text = article.get('title', '')
            if article.get('description'):
                text += ' ' + article['description']
            
            if text:
                sentiment = sia.polarity_scores(text)
                sentiments.append(sentiment['compound'])
        
        avg_sentiment = np.mean(sentiments) if sentiments else 0
        return avg_sentiment
    except Exception as e:
        print(f"Error al obtener el sentimiento para {symbol} en la fecha {date}: {e}")
        return 0

Für den Backtest werden wir news-api als Feed verwenden, da wir über deren kostenlose API einen 1-Monats-Rückblick auf Nachrichten erhalten können. Wenn Sie mehr benötigen, können Sie ein Abonnement abschließen.

Der Rest des Codes dient dazu, die Vorhersagen des ONNX-Modells zu erhalten, um die nächsten Schlusskurse vorherzusagen. Wir vergleichen einfach das Sentiment mit den Vorhersagen des Deep Learning, und wenn beide zu den gleichen Ergebnissen kommen, wird ein Auftrag erstellt. Jetzt sieht es so aus:

investment_df = comparison_df.copy()
investment_df['price_direction'] = np.where(investment_df['prediction'].shift(-1) > investment_df['prediction'], 1, -1)
investment_df['sentiment_direction'] = np.where(investment_df['sentiment'] > 0, 1, -1)
investment_df['position'] = np.where(investment_df['price_direction'] == investment_df['sentiment_direction'], investment_df['price_direction'], 0)
investment_df['strategy_returns'] = investment_df['position'] * (investment_df['actual'].shift(-1) - investment_df['actual']) / investment_df['actual']
investment_df['buy_and_hold_returns'] = (investment_df['actual'].shift(-1) - investment_df['actual']) / investment_df['actual']

Der Code erstellt zunächst eine Kopie von „comparison_df“ und nennt sie „investment_df“. Dann wird eine neue Spalte mit der Bezeichnung „price_direction“ hinzugefügt, die den Wert 1 annimmt, wenn die nächste Vorhersage höher ist als die aktuelle Vorhersage, und ansonsten den Wert -1. Als Nächstes wird eine weitere Spalte mit der Bezeichnung „sentiment_direction“ hinzugefügt, die den Wert 1 annimmt, wenn die Stimmung positiv ist, und -1, wenn sie negativ ist. Dann wird eine Spalte mit dem Namen „Position“ hinzugefügt, die den Wert „price_direction“ annimmt, wenn sie mit „sentiment_direction“ übereinstimmt, und andernfalls 0. Der Code berechnet dann „strategy_returns“ durch Multiplikation von „position“ mit der relativen Veränderung der tatsächlichen Werte von einer Zeile zur nächsten. Schließlich wird die „buy_and_hold_returns“ als relative Veränderung der tatsächlichen Werte von einer Zeile zur nächsten ohne Berücksichtigung der Positionen berechnet.

Die Ergebnisse dieses Backtests sehen wie folgt aus:

Datos normalizados guardados en 'binance_data_normalized.csv'
Sentimientos diarios guardados en 'daily_sentiments.csv'
Predicciones y sentimiento guardados en 'predicted_data_with_sentiment.csv'
Mean Absolute Error (MAE): 30.66908467315391
Root Mean Squared Error (RMSE): 36.99641752814565
R-squared (R2): 0.9257591918098058
Mean Absolute Percentage Error (MAPE): 0.00870572230484879
Gráfica guardada como 'ETH_USDT_price_prediction.png'
Gráfica de residuales guardada como 'ETH_USDT_residuals.png'
Correlation between actual and predicted prices: 0.9752007459642241
Gráfica de estrategia de inversión guardada como 'ETH_USDT_investment_strategy.png'
Gráfica de drawdown guardada como 'ETH_USDT_drawdown.png'
Sharpe Ratio: 9.41431958149606
Sortino Ratio: 11800588386323879936.0000
Número de rendimientos totales: 28
Número de rendimientos en exceso: 28
Número de rendimientos negativos: 19
Media de rendimientos en exceso: 0.005037
Desviación estándar de rendimientos negativos: 0.000000
Sortino Ratio: nan
Beta: 0.33875104783408166
Alpha: 0.006981197358213854
Cross-Validation MAE: 1270.7809910146143 ± 527.5746657573876
SMA Mean Absolute Error (MAE): 344.3737716856061
SMA Mean Absolute Error (MAE): 344.3737716856061
SMA Root Mean Squared Error (RMSE): 483.0396130996611
SMA R-squared (R2): 0.5813550203375846
Gráfica de predicción SMA guardada como 'ETH_USDT_sma_price_prediction.png'
Gráfica de precio, predicción y sentimiento guardada como 'ETH_USDT_price_prediction_sentiment.png'
Gráfica de drawdown guardada como 'ETH_USDT_drawdown.png'
Maximum Drawdown: 0.00%

Wie die Ergebnisse zeigen, ist die Korrelation zwischen den vorhergesagten Preisen und den realen Preisen sehr gut. R2, eine Kennzahl zur Messung der Güte der Vorhersagen des Modells, sieht ebenfalls gut aus. Die Sharpe Ratio ist höher als 5, was hervorragend ist, ebenso wie der Sortino. Auch andere Ergebnisse werden in Diagrammen dargestellt.

Das Diagramm, das die Strategie mit dem Halten vergleicht, sieht wie folgt aus:

Andere Diagramme wie Preisvorhersage vs. tatsächlicher Preis

und, aktueller Preis, Preisvorhersage und Stimmung

Die Ergebnisse zeigen, diese Strategie ist sehr profitabel, sodass wir mit diesem Argument nun einen EA erstellen werden.

Dieser EA sollte zwei Python-Skripte enthalten, die die Sentiment-Analyse und das Deep-Learning-Modell erstellen, und alle sollten zusammengeführt werden, um im EA zu funktionieren.

ONNX-Modell

Der Code für die Datenerfassung, das Training und das ONNX-Modell bleibt derselbe wie in früheren Artikeln. Daher werde ich im Folgenden den Python-Code für die Stimmungsanalyse erläutern.

Sentiment-Analyse mit Python

Wir werden die Bibliotheken „requests“ und „TextBlob“ verwenden, um Devisennachrichten abzurufen und eine Stimmungsanalyse durchzuführen, zusammen mit der „csv“-Bibliothek zum Lesen und Schreiben von Daten. Zusätzlich werden die Bibliotheken „datetime“ und „time“ verwendet.

import requests
from textblob import TextBlob
import csv
from datetime import datetime
import time
from time import sleep

Die Idee für dieses Skript ist es, zunächst den Start um einige Sekunden zu verzögern (um sicherzustellen, dass der nächste Teil des Skripts ordnungsgemäß funktionieren kann). Der zweite Teil des Skripts liest den API-Schlüssel, den wir verwenden wollen. In diesem Fall verwenden wir die Marketaux-API, die eine Reihe von kostenlosen Nachrichten und kostenlosen Aufrufen bietet. Es gibt noch weitere Optionen wie News API, Alpha Vantage oder Finhub, von denen einige kostenpflichtig sind, aber mehr Nachrichten, einschließlich historischer Nachrichten, liefern und ein Backtesting der Strategie im MT5 ermöglichen. Wie bereits erwähnt, werden wir vorerst Marketaux verwenden, da es eine kostenlose API hat, um tägliche Nachrichten zu erhalten. Wenn wir andere Quellen verwenden wollen, müssen wir den Code anpassen.

Hier ist ein Entwurf, wie das Drehbuch aufgebaut sein könnte:

Hier ist die Funktion zum Lesen des API-Schlüssels aus der Eingabe des EA:

api_file_path = 'C:/Users/jsgas/AppData/Roaming/MetaQuotes/Terminal/24F345EB9F291441AFE537834F9D8A19/MQL5/Files/Files/api.txt'
print(api_file_path)

def read_api_from_file():
    try:
        with open(api_file_path, 'r', encoding='utf-16') as file:
            raw_data = file.read()
            print(f"Raw data from file: {repr(raw_data)}")  # Print raw data
            api = raw_data.strip()  # Lee el contenido y elimina espacios en blanco adicionales
            api = api.replace('\ufeff', '')  # Remove BOM character if present
            print(f"API after stripping whitespace: {api}")
            time.sleep(5)
            return api
    except FileNotFoundError:
        print(f"El archivo {api_file_path} no existe.")
        time.sleep(5)
        return None




# Configuración de la API de Marketaux
api=read_api_from_file()
MARKETAUX_API_KEY = api

Bevor wir die Nachrichten lesen, müssen wir wissen, was zu lesen ist, und dafür werden wir dieses Python-Skript aus einer Textdatei lesen lassen, die vom EA erstellt wurde, sodass das Python-Skript weiß, was zu lesen ist oder welches Symbol zu studieren und Nachrichten zu erhalten ist, und welcher API-Schlüssel im EA eingegeben wird, welches Datum heute ist, damit das Modell fertig wird und die Nachrichten für dieses Datum ankommen.

Es muss auch in der Lage sein, eine txt- oder csv-Datei zu schreiben, damit sie als Input für den EA mit den Ergebnissen des Sentiment dient.

def read_symbol_from_file():
    try:
        with open(symbol_file_path, 'r', encoding='utf-16') as file:
            raw_data = file.read()
            print(f"Raw data from file: {repr(raw_data)}")  # Print raw data
            symbol = raw_data.strip()  # Lee el contenido y elimina espacios en blanco adicionales
            symbol = symbol.replace('\ufeff', '')  # Remove BOM character if present
            print(f"Symbol after stripping whitespace: {symbol}")
            return symbol
    except FileNotFoundError:
        print(f"El archivo {symbol_file_path} no existe.")
        return None

def save_sentiment_to_txt(average_sentiment, file_path='C:/Users/jsgas/AppData/Roaming/MetaQuotes/Terminal/24F345EB9F291441AFE537834F9D8A19/MQL5/Files/Files/'+str(symbol)+'sentiment.txt'):
    with open(file_path, 'w') as f:
        f.write(f"{average_sentiment:.2f}")

if symbol:
    news, current_rate = get_forex_news(symbol)

    if news:
        print(f"Noticias para {symbol}:")
        for i, (title, description) in enumerate(news, 1):
            print(f"{i}. {title}")
            print(f"   {description[:100]}...")  # Primeros 100 caracteres de la descripción
        
        print(f"\nTipo de cambio actual: {current_rate if current_rate else 'No disponible'}")

        # Calcular el sentimiento promedio
        sentiment_scores = [TextBlob(title + " " + description).sentiment.polarity for title, description in news]
        average_sentiment = sum(sentiment_scores) / len(sentiment_scores) if sentiment_scores else 0
        print(f"Sentimiento promedio: {average_sentiment:.2f}")

        # Guardar resultados en CSV
        #save_to_csv(symbol, current_rate, average_sentiment)

        # Guardar sentimiento promedio en un archivo de texto
        save_sentiment_to_txt(average_sentiment)
        print("Sentimiento promedio guardado en 'sentiment.txt'")
    else:
        print("No se pudieron obtener noticias de Forex.")
else:
    print("No se pudo obtener el símbolo del archivo.")

Die Leser müssen das gesamte Skript anpassen, je nachdem, für was etwas benötigt wird: Forex, Aktien oder Krypto.

Der Expert Advisor

Um die Python-Skripte auszuführen, müssen wir die Datei shell32.dll wie folgt einbinden

#include <WinUser32.mqh>

#import "shell32.dll"
int ShellExecuteW(int hwnd, string lpOperation, string lpFile, string lpParameters, string lpDirectory, int nShowCmd);
#import

Wir müssen die Python-Skripte zum Ordner File hinzufügen

string script1 = "C:\\Users\\jsgas\\AppData\\Roaming\\MetaQuotes\\Terminal\\24F345EB9F291441AFE537834F9D8A19\\MQL5\\Files\\Files\\dl model for mql5 v6 Final EURUSD_bien.py";
string script2 = "C:\\Users\\jsgas\\AppData\\Roaming\\MetaQuotes\\Terminal\\24F345EB9F291441AFE537834F9D8A19\\MQL5\\Files\\Files\\sentiment analysis marketaux v6 Final EURUSD_bien.py";

Und alle Pfade zu den Ein- und Ausgängen der Python-Skripte

// Ruta del archivo donde se escribirá el símbolo
string filePathSymbol = "//Files//symbol.txt";
// Ruta del archivo donde se escribirá el timeframe
string filePathTimeframe = "//Files//timeframe.txt";
string filePathTime = "//Files//time.txt";
string filePathApi = "//Files//api.txt";

string fileToSentiment = "//Files//"+Symbol()+"sentiment.txt";



string file_add = "C://Users//jsgas//AppData//Roaming//MetaQuotes//Terminal//24F345EB9F291441AFE537834F9D8A19//MQL5//Files";
string file_str = "//Files//model_";
string file_str_final = ".onnx";
string file_str_nexo = "_";

string file_add2 = "C:\\Users\\jsgas\\AppData\\Roaming\\MetaQuotes\\Terminal\\24F345EB9F291441AFE537834F9D8A19\\MQL5\\Files";
string file_str2 = "\\Files\\model_";
string file_str_final2 = ".onnx";
string file_str_nexo2 = "_";

Wir müssen den api-Schlüssel von Marketaux eingeben

input string api_key      = "mWpORHgs3GdjqNZkxZwnXmrFLYmG5jhAbVrF";           // MARKETAUX_API_KEY www.marketaux.com

Diesen können wir von hier abrufen, und er sieht wie folgt aus:

Ich arbeite nicht für Marketaux, Sie können also jeden anderen Newsfeed oder jedes andere Abonnement verwenden, das Sie wollen/brauchen.

Sie müssen eine Magic Number einrichten, damit die Aufträge nicht verwechselt werden.

int OnInit()
  {
   ExtTrade.SetExpertMagicNumber(Magic_Number);

Sie können es auch hier hinzufügen

void OpenBuyOrder(double lotSize, double slippage, double stopLoss, double takeProfit)
  {
// Definir la estructura MqlTradeRequest
   MqlTradeRequest request;
   MqlTradeResult result;

// Inicializar la estructura de la solicitud
   ZeroMemory(request);

// Establecer los parámetros de la orden
   request.action   = TRADE_ACTION_DEAL;
   request.symbol   = _Symbol;
   request.volume   = lotSize;
   request.type     = ORDER_TYPE_BUY;
   request.price    = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   request.deviation= slippage;
   request.sl       = stopLoss;
   request.tp       = takeProfit;
   request.magic    = Magic_Number;
   request.comment  = "Buy Order";

// Enviar la solicitud de comercio
   if(!OrderSend(request,result))
     {
      Print("Error al abrir orden de compra: ", result.retcode);

Der letzte Codeschnipsel zeigt, wie der Auftrag ausgeführt wird. Sie können auch den Handel von CTrade verwenden, um Aufträge auszuführen.

Dadurch wird eine Datei geschrieben (die als Eingabe in den .py-Skripten verwendet werden kann):

void WriteToFile(string filePath, string data)
  {
   Print("Intentando abrir el archivo: ", filePath);
// Abre el archivo en modo de escritura, crea el archivo si no existe
   int fileHandle = FileOpen(filePath, FILE_WRITE | FILE_TXT);
   if(fileHandle != INVALID_HANDLE)
     {
      // Escribe los datos en el archivo
      FileWriteString(fileHandle, data);
      FileClose(fileHandle);  // Cierra el archivo
      Print("Archivo escrito exitosamente: ", filePath);
     }
   else
     {
      Print("Error al abrir el archivo ", filePath, ". Código de error: ", GetLastError());
     }
  }

Dadurch werden das Symbol, der Zeitrahmen und das aktuelle Datum in die Datei geschrieben:

void WriteSymbolAndTimeframe()
  {
// Obtén el símbolo actual
   currentSymbol = Symbol();
// Obtén el período de tiempo del gráfico actual
   string currentTimeframe = GetTimeframeString(Period());
   currentTime = TimeToString(TimeCurrent(), TIME_DATE);

// Escribe cada dato en su respectivo archivo
   WriteToFile(filePathSymbol, currentSymbol);
   WriteToFile(filePathTimeframe, currentTimeframe);
   WriteToFile(filePathTime, currentTime);
   WriteToFile(filePathApi,api_key);

   Sleep(10000); // Puedes ajustar o eliminar esto según sea necesario
  }

Die Funktion WriteSymbolAndTimeframe erfüllt die folgenden Aufgaben:

1. Zunächst wird das aktuelle Handelssymbol abgerufen und in currentSymbol gespeichert
2. Dann wird der Zeitrahmen des aktuellen Diagramms mit GetTimeframeString(Period()) als Zeichenkette abgerufen und in currentTimeframe gespeichert
3. Außerdem wird mit TimeToString(TimeCurrent(), TIME_DATE) die aktuelle Zeit in einem bestimmten Format abgerufen und in currentTime gespeichert
4. Anschließend wird jeder dieser Werte in die entsprechende Datei geschrieben:
• currentSymbol wird in filePathSymbol geschrieben
• currentTimeframe wird in filePathTimeframe geschrieben
• currentTime wird in filePathTime geschrieben
• api_key wird in filePathApi geschrieben
5. Schließlich pausiert die Funktion 10 Sekunden lang mit Sleep(10000), was je nach Bedarf angepasst oder aufgehoben werden kann.

Damit können wir die Skripte starten:

void OnTimer()
  {
   datetime currentTime2 = TimeCurrent();

// Verifica si ha pasado el intervalo para el primer script
   if(currentTime2 - lastExecutionTime1 >= interval1)
     {
      // Escribe los datos necesarios antes de ejecutar el script
      WriteSymbolAndTimeframe();

      // Ejecuta el primer script de Python
      int result = ShellExecuteW(0, "open", "cmd.exe", "/c python \"" + script1 + "\"", "", 1);
      if(result > 32)
         Print("Script 1 iniciado exitosamente");
      else
         Print("Error al iniciar Script 1. Código de error: ", result);
      lastExecutionTime1 = currentTime2;
     }

Die Funktion „OnTimer“ wird periodisch ausgeführt und erfüllt die folgenden Aufgaben:

1. Zunächst wird die aktuelle Zeit abgerufen und in „currentTime2“ gespeichert.
2. Dann wird geprüft, ob die seit der letzten Ausführung des ersten Skripts verstrichene Zeit („lastExecutionTime1“) größer oder gleich einem vordefinierten Intervall („interval1“) ist.
3. Wenn die Bedingung erfüllt ist, werden die erforderlichen Daten durch den Aufruf von „WriteSymbolAndTimeframe“ geschrieben.
4. Als Nächstes wird das erste Python-Skript ausgeführt, indem ein Befehl über „ShellExecuteW“ ausgeführt wird, der „cmd.exe“ öffnet und das durch „script1“ angegebene Python-Skript ausführt.
5. Wenn die Ausführung des Skripts erfolgreich ist (angezeigt durch ein Ergebnis größer als 32), wird eine Erfolgsmeldung ausgegeben; andernfalls wird eine Fehlermeldung mit dem entsprechenden Fehlercode ausgegeben.
6. Schließlich wird „lastExecutionTime1“ auf die aktuelle Zeit („currentTime2“) aktualisiert.

Mit dieser Funktion können wir die Datei lesen:

string ReadFile(string file_name)
  {
   string result = "";
   int handle = FileOpen(file_name, FILE_READ|FILE_TXT|FILE_ANSI); // Use FILE_ANSI for plain text

   if(handle != INVALID_HANDLE)
     {
      int file_size = FileSize(handle); // Get the size of the file
      result = FileReadString(handle, file_size); // Read the whole file content
      FileClose(handle);
     }
   else
     {
      Print("Error opening file: ", file_name);
     }

   return result;
  }

Der Code definiert eine Funktion mit dem Namen ReadFile, die einen Dateinamen als Argument nimmt und den Dateiinhalt als String zurückgibt. Zuerst wird eine leerer Zeichenkette initialisiert, dann wird versucht, die Datei mit Leseberechtigungen und im Klartextmodus mit FileOpen zu öffnen. Wenn das Dateihandle gültig ist, wird die Dateigröße mit FileSize ermittelt, der gesamte Dateiinhalt mit FileReadString in das Ergebnis gelesen und dann die Datei mit FileClose geschlossen. Wenn der Dateihandle ungültig ist, wird eine Fehlermeldung mit dem Dateinamen gedruckt und schließlich das Ergebnis mit dem Dateiinhalt zurückgegeben.

Wenn wir diese Bedingung ändern, können wir die Stimmung als eine weitere hinzufügen:

   if(ExtPredictedClass==PRICE_DOWN && Sentiment_number<0)
      signal=ORDER_TYPE_SELL;    // sell condition
   else
     {
      if(ExtPredictedClass==PRICE_UP && Sentiment_number>0)
         signal=ORDER_TYPE_BUY;  // buy condition
      else
         Print("No order possible");
     }

Die Stimmung geht in diesem Fall von 10 bis -10, wobei 0 ein neutrales Signal ist. Sie können diese Strategie nach Belieben ändern.

Der Rest des Codes ist der einfache EA aus dem Artikel Wie man ONNX-Modelle in MQL5 verwendet mit ein paar Änderungen.

Dies ist kein komplett fertiger EA, sondern nur ein einfaches Beispiel dafür, wie man mit Python und mql5 einen Sentiment & Deep Learning Expert Advisor erstellt. Je mehr Zeit Sie in diesen EA investieren, desto weniger Fehler und Probleme werden Sie bekommen. Dies ist eine innovative Fallstudie, und das Backtesting zeigt vielversprechende Ergebnisse. Ich hoffe, Sie finden diesen Artikel hilfreich, und wenn es jemandem gelingt, eine gute Probe von Nachrichten zu erhalten oder es für einige Zeit zum Laufen zu bringen, teilen Sie bitte Ihre Ergebnisse mit. Um die Strategie zu testen, sollten Sie ein Demokonto verwenden.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Integration von Deep Learning und Sentiment-Analyse in MetaTrader 5 (MQL5) Handelsstrategien ein Beispiel für die fortschrittlichen Möglichkeiten des modernen algorithmischen Handels ist. Durch die Nutzung von Python-Skripten über eine DLL shell32.dll-Schnittstelle können wir komplexe Modelle nahtlos ausführen und wertvolle Stimmungsdaten gewinnen, wodurch sich Handelsentscheidungen und -ergebnisse verbessern. Der skizzierte Prozess umfasst die Verwendung von Python zum Abrufen und Analysieren der Nachrichtenstimmung, die Ausführung von ONNX-Modellen für Preisvorhersagen und die Ausführung von Geschäften, wenn beide Indikatoren übereinstimmen.

Die Backtesting-Ergebnisse belegen die potenzielle Rentabilität der Strategie, die sich in starken Korrelationskennzahlen, hohen R-Quadrat-Werten und ausgezeichneten Sharpe- und Sortino-Ratios zeigt. Diese Ergebnisse deuten darauf hin, dass die Kombination von Stimmungsanalyse und Deep Learning die Genauigkeit von Handelssignalen und die Gesamtleistung der Strategie erheblich verbessern kann.

Die Entwicklung eines voll funktionsfähigen Expert Advisors (EA) erfordert eine sorgfältige Integration verschiedener Komponenten, darunter Python-Skripte für die Sentiment-Analyse und ONNX-Modelle für die Preisvorhersage. Durch die kontinuierliche Verfeinerung dieser Elemente und die Anpassung der Strategie an verschiedene Märkte und Datenquellen können Händler ein robustes und effektives Handelsinstrument aufbauen.

Diese Studie dient als Grundlage für alle, die an der Erforschung der Konvergenz von maschinellem Lernen, Stimmungsanalyse und algorithmischem Handel interessiert sind, und bietet einen Weg zu besser informierten und potenziell profitablen Handelsentscheidungen.