Análisis de sentimientos y aprendizaje profundo para operar con EA y backtesting con Python

Introducción

La integración del aprendizaje profundo y el análisis de sentimientos en las estrategias de trading en MetaTrader 5 (MQL5) representa un sofisticado avance en el trading algorítmico. El aprendizaje profundo, un subconjunto del aprendizaje automático, implica redes neuronales con múltiples capas que pueden aprender y hacer predicciones a partir de conjuntos de datos vastos y complejos. El análisis de sentimiento, por su parte, es una técnica de procesamiento del lenguaje natural (Natural Language Processing, NLP) que se utiliza para determinar el sentimiento o el tono emocional de un texto. Aprovechando estas tecnologías, los operadores pueden mejorar sus procesos de toma de decisiones y los resultados de sus operaciones.

Para este artículo, integraremos Python en MQL5 usando una DLL (shell32.dll), que ejecuta lo que necesitamos para Windows. Instalando Python y ejecutándolo a través de shell32.dll, podremos lanzar scripts Python desde el MQL5 Expert Advisor (EA). Hay dos scripts de Python: Uno para ejecutar el modelo ONNX entrenado a partir de TensorFlow, y otro script que utiliza bibliotecas para obtener noticias de Internet, leer los titulares y cuantificar el sentimiento de los medios utilizando IA. Esta es una posible solución, pero hay muchas maneras y diferentes fuentes para obtener el sentimiento de una acción o símbolo. Una vez obtenidos el modelo y el sentimiento, si ambos valores coinciden, la orden es ejecutada por el EA.

¿Podemos realizar una prueba en Python para comprender los resultados de combinar el análisis de sentimientos y el aprendizaje profundo? La respuesta es sí, y procederemos a estudiar el código.

Backtesting de análisis de sentimientos con aprendizaje profundo usando Python

Para realizar el backtesting de esta estrategia, utilizaremos las siguientes librerías. Utilizaré mi otro artículo como punto de partida. De todos modos, aquí también daré las explicaciones necesarias.

Utilizaremos las siguientes bibliotecas:

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

En primer lugar, nos aseguramos de que 'nltk' está actualizado.

nltk.download('vader_lexicon')

nltk (Natural Language Toolkit) es una biblioteca utilizada para trabajar con datos del lenguaje humano (texto). Proporciona interfaces fáciles de usar para más de 50 corpus y recursos léxicos, como WordNet, junto con un conjunto de bibliotecas de procesamiento de texto para clasificación, tokenización, derivación, etiquetado, análisis y razonamiento semántico, así como envoltorios para bibliotecas NLP de nivel industrial.

Los lectores deben adaptar el script de backtesting en python para especificar dónde obtener los datos, el feed de noticias y los datos para los modelos ONNX.

Para obtener el análisis de sentimiento utilizaremos lo siguiente:

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

Para la prueba retrospectiva, utilizaremos 'news-api' como fuente, ya que su API gratuita nos permite obtener noticias con un mes de antelación. Si necesita más, puede adquirir una suscripción.

El resto del código será obtener las predicciones del modelo ONNX para predecir los próximos precios de cierre. Simplemente compararemos el sentimiento con las predicciones del aprendizaje profundo, y si ambos concluyen con los mismos resultados, se creará una orden. Se parece a esto:

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']

El código crea primero una copia de `comparison_df` y la denomina `investment_df`. A continuación, añade una nueva columna llamada `price_direction` que toma el valor de 1 si la siguiente predicción es mayor que la predicción actual y -1 en caso contrario. A continuación añade otra columna llamada `sentiment_direction` que toma el valor de 1 si el sentimiento es positivo y -1 si es negativo. Luego añade una columna llamada `position` que toma el valor de `price_direction` si coincide con `sentiment_direction` y 0 en caso contrario. A continuación, el código calcula `strategy_returns` multiplicando `position` por el cambio relativo de los valores reales de una fila a la siguiente. Por último, calcula `buy_and_hold_returns` como el cambio relativo de los valores reales de una fila a otra sin tener en cuenta las posiciones.

Los resultados de este backtest son los siguientes:

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%

Como dicen los resultados, la correlación entre los precios previstos y los precios reales es muy buena. R2, que es una métrica para medir la calidad de las predicciones del modelo, también parece buena. El ratio de Sharpe es superior a 5, lo que es excelente, así como el Sortino. Además, otros resultados se muestran en el gráfico.

El gráfico que compara la estrategia vs mantener se ve así:

Otros gráfico como la predicción de precios frente al precio real:

Precio actual, predicción de precios y sentimiento:

Los resultados muestran que esta estrategia es muy rentable, por lo que ahora estamos usando este argumento para crear un EA.

Este EA debe tener dos scripts de Python que realicen el análisis de sentimientos y el modelo de aprendizaje profundo, y todos deben fusionarse para funcionar en el EA.

Modelo ONNX

El código para la adquisición de datos, el entrenamiento y el modelo ONNX sigue siendo el mismo que usamos en artículos anteriores. Por lo tanto, procederé a discutir el código Python para el análisis de sentimientos.

Análisis de sentimientos con Python

Utilizaremos las bibliotecas `requests` y `TextBlob` para obtener noticias de Forex y realizar análisis de sentimiento, junto con la biblioteca `csv` para leer y escribir datos. Además, se utilizarán las bibliotecas `datetime` y `time`.

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

La idea de este script es, primero, retrasarlo unos segundos antes de comenzar (para garantizar que la siguiente parte del script pueda funcionar correctamente). La segunda parte del script leerá la clave API que queremos usar. Para este caso, utilizaremos la API de Marketaux, que ofrece una serie de noticias y llamadas gratuitas. Hay más opciones como News API, Alpha Vantage o Finhub, algunas de las cuales son de pago pero proporcionan más noticias, incluidas noticias históricas, lo que permite realizar pruebas retrospectivas de la estrategia en MT5. Como se mencionó anteriormente, utilizaremos Marketaux por ahora, ya que tiene una API gratuita para obtener noticias diarias. Si queremos utilizar otras fuentes, necesitaremos adaptar el código.

A continuación se muestra un borrador de cómo podría estructurarse el guión:

Aquí está la función para leer la clave API desde la entrada del 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

Antes de leer las noticias, necesitamos saber qué leer, y para eso, haremos que este script de Python lea desde un archivo de texto creado por el EA, para que el script de Python sepa qué leer o qué símbolo estudiar y obtener noticias, y, qué clave API se ingresa en el EA, qué fecha es hoy para que el modelo esté listo y las noticias lleguen para esta fecha.

También debe ser capaz de escribir un TXT o CSV para que sirva como entrada al EA, con los resultados del sentimiento.

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.")

Los lectores deben adaptar todo el guión dependiendo del estudio; forex, acciones o criptomonedas.

El asesor experto

Debemos incluir shell32.dll aquí para ejecutar los scripts de Python.

#include <WinUser32.mqh>

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

Debemos agregar los scripts de Python a la carpeta File.

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";

Y todas las rutas a las entradas y salidas de los scripts de Python.

// 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 = "_";

Debemos ingresar la clave API de Marketaux.

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

Podemos obtener eso de aquí, y se verá así:

No trabajo para Marketaux, por lo que puedes utilizar cualquier otro servicio de noticias o suscripción que quieras o necesites.

Tendrás que configurar un número mágico, para que no se mezclen los pedidos.

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

También debes agregarlo aquí.

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);

Ese último fragmento de código es cómo se realiza el pedido, también puedes usar el comercio de CTrade para realizar pedidos.

Esto escribirá un archivo (para usar como entrada en los scripts .py):

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());
     }
  }

Esto escribirá el símbolo, el período de tiempo y la fecha actual en el archivo:

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
  }

La función WriteSymbolAndTimeframe realiza las siguientes tareas:

1. Primero, recupera el símbolo comercial actual y lo almacena en currentSymbol.
2. Luego, obtiene el período de tiempo del gráfico actual como una cadena usando GetTimeframeString(Period()) y lo almacena en currentTimeframe.
3. También obtiene la hora actual en un formato específico usando TimeToString(TimeCurrent(), TIME_DATE) y la almacena en currentTime.
4. A continuación, escribe cada uno de estos valores en sus respectivos archivos:
• currentSymbol se escribe en filePathSymbol
• currentTimeframe se escribe en filePathTimeframe
• currentTime se escribe en filePathTime
• api_key se escribe en filePathApi
5. Finalmente, la función se pausa durante 10 segundos usando Sleep(10000), que se puede ajustar o eliminar según sea necesario.

Podemos lanzar los scripts con esto:

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;
     }

La función `OnTimer` se ejecuta periódicamente y realiza las siguientes tareas:

1. Primero, recupera la hora actual y la almacena en `currentTime2`.
2. Luego verifica si el tiempo transcurrido desde la última ejecución del primer script (`lastExecutionTime1`) es mayor o igual a un intervalo predefinido (`interval1`).
3. Si se cumple la condición, escribe los datos necesarios llamando a `WriteSymbolAndTimeframe`.
4. A continuación, ejecuta el primer script de Python ejecutando un comando a través de `ShellExecuteW` que abre `cmd.exe` y ejecuta el script de Python especificado por `script1`.
5. Si la ejecución del script es exitosa (indicado por un resultado mayor a 32), imprime un mensaje de éxito; de lo contrario, imprime un mensaje de error con el código de error correspondiente.
6. Finalmente, actualiza `lastExecutionTime1` a la hora actual (`currentTime2`).

Podemos leer el archivo con esta función:

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;
  }

El código define una función llamada ReadFile que toma un nombre de archivo como argumento y devuelve el contenido del archivo como una cadena (string), primero inicializa un resultado de cadena vacía, luego intenta abrir el archivo con permisos de lectura y en modo de texto simple usando FileOpen si el identificador de archivo es válido, obtiene el tamaño del archivo usando FileSize, lee todo el contenido del archivo en el resultado usando FileReadString y luego cierra el archivo usando FileClose si el identificador de archivo no es válido, imprime un mensaje de error con el nombre del archivo finalmente, devuelve el resultado que contiene el contenido del archivo.

Cambiando esta condición, podemos agregar el sentimiento como uno más:

   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");
     }

El sentimiento en este caso va de 10 a -10, siendo 0 una señal neutral. Puedes modificar esta estrategia como quieras.

El resto del código es el EA simple utilizado en el artículo Uso de modelos ONNX en MQL5, con algunas modificaciones.

Este no es un EA completo y terminado, es solo un ejemplo simple de cómo usar Python y MQL5 para crear un asesor experto de sentimiento y aprendizaje profundo. Cuanto más tiempo inviertas en este EA, menos errores y problemas tendrás. Este es un estudio de caso de vanguardia y las pruebas retrospectivas muestran resultados prometedores. Espero que este artículo te sea útil, y si alguien logra obtener una buena muestra de noticias o hace que funcione por algún tiempo, por favor comparte los resultados. Para probar la estrategia, debes utilizar una cuenta demo.

Conclusión

En conclusión, la integración del aprendizaje profundo y el análisis de sentimientos en las estrategias comerciales de MetaTrader 5 (MQL5) ejemplifica las capacidades avanzadas del comercio algorítmico moderno. Al aprovechar los scripts de Python a través de una interfaz DLL shell32.dll, podemos ejecutar sin problemas modelos complejos y obtener datos de sentimiento valiosos, mejorando así las decisiones y los resultados comerciales. El proceso descrito incluye el uso de Python para obtener y analizar el sentimiento de las noticias, ejecutar modelos ONNX para predicciones de precios y ejecutar operaciones cuando ambos indicadores se alinean.

Los resultados del backtesting demuestran la rentabilidad potencial de la estrategia, como lo indican las fuertes métricas de correlación, los altos valores R-cuadrado (R2) y los excelentes ratios de Sharpe y Sortino. Estos hallazgos sugieren que la combinación del análisis de sentimientos con el aprendizaje profundo puede mejorar significativamente la precisión de las señales comerciales y el rendimiento general de la estrategia.

De cara al futuro, el desarrollo de un asesor experto completamente funcional implica una integración meticulosa de varios componentes, incluidos scripts de Python para el análisis de sentimientos y modelos ONNX para la predicción de precios. Al perfeccionar continuamente estos elementos y adaptar la estrategia a diferentes mercados y fuentes de datos, los operadores pueden construir una herramienta comercial sólida y efectiva.

Este estudio sirve como base para aquellos interesados en explorar la convergencia del aprendizaje automático, el análisis de sentimientos y el comercio algorítmico, ofreciendo un camino hacia decisiones comerciales más informadas y potencialmente rentables.