Análise de Sentimento e Deep Learning para Trading com EA e Backtesting com Python

Introdução

Integrar deep learning e análise de sentimento em estratégias de trading no MetaTrader 5 (MQL5) representa um avanço sofisticado no trading algorítmico. Deep learning, um subconjunto de machine learning, envolve redes neurais com múltiplas camadas que podem aprender e fazer previsões a partir de grandes e complexos conjuntos de dados. Análise de sentimento, por outro lado, é uma técnica de processamento de linguagem natural (NLP) usada para determinar o sentimento ou tom emocional por trás de um corpo de texto. Ao aproveitar essas tecnologias, os traders podem melhorar seus processos de tomada de decisão e otimizar os resultados de trading.

Para este artigo, vamos integrar o Python ao MQL5 usando uma DLL shell32.dll, que executa o que precisamos para o Windows. Instalando o Python e executando-o através da shell32.dll, seremos capazes de lançar scripts Python a partir do Expert Advisor (EA) do MQL5. Existem dois scripts Python: um para executar o modelo ONNX treinado do TensorFlow e outro que utiliza bibliotecas para buscar notícias da internet, ler as manchetes e quantificar o sentimento da mídia usando IA. Esta é uma possível solução, mas há muitas maneiras e fontes diferentes para obter o sentimento de uma ação ou símbolo. Uma vez que o modelo e o sentimento sejam obtidos, se ambos os valores estiverem de acordo, a ordem será executada pelo EA.

Podemos realizar um teste em Python para entender os resultados da combinação de análise de sentimento e deep learning? A resposta é sim, e vamos prosseguir para estudar o código.

Backtesting de Análise de Sentimento com Deep Learning usando Python

Para realizar o backtesting dessa estratégia, vamos usar as seguintes bibliotecas. Vou usar meu outro artigo como ponto de partida. De qualquer forma, aqui também fornecerei as explicações necessárias.

Vamos usar as seguintes 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

Primeiro de tudo, garantimos que o nltk está atualizado.

nltk.download('vader_lexicon')

nltk (Natural Language Toolkit) é uma biblioteca usada para trabalhar com dados de linguagem humana (texto). Ela fornece interfaces fáceis de usar para mais de 50 corpora e recursos lexicais, como o WordNet, junto com um conjunto de bibliotecas de processamento de texto para classificação, tokenização, stemming, tagging, parsing, raciocínio semântico, além de wrappers para bibliotecas NLP de alto desempenho.

Os leitores devem adaptar o script de backtesting em Python para especificar de onde obter dados, feed de notícias e dados para modelos ONNX.

Usaremos o seguinte para obter a análise de sentimento:

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 o backtest, usaremos a news-api como feed, pois sua API gratuita nos permite obter notícias de até 1 mês atrás. Se precisar de mais, pode comprar uma assinatura.

O restante do código será para obter as previsões do modelo ONNX para prever os preços de fechamento futuros. Vamos apenas comparar o sentimento com as previsões de deep learning e, se ambos concluírem com os mesmos resultados, uma ordem será criada. Isso se parece com o seguinte:

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

O código primeiro cria uma cópia de comparison_df e a nomeia como investment_df. Em seguida, adiciona uma nova coluna chamada price_direction, que recebe o valor de 1 se a próxima previsão for maior que a previsão atual e -1 caso contrário. Depois, adiciona outra coluna chamada sentiment_direction, que recebe o valor de 1 se o sentimento for positivo e -1 se for negativo. Em seguida, adiciona uma coluna chamada position, que recebe o valor de price_direction se corresponder a sentiment_direction e 0 caso contrário. O código então calcula strategy_returns multiplicando position pela mudança relativa nos valores reais de uma linha para a próxima. Por fim, calcula buy_and_hold_returns como a mudança relativa nos valores reais de uma linha para a próxima sem considerar as posições.

Os resultados desse backtest se parecem com isto:

Dados normalizados guardados em 'binance_data_normalized.csv'
Sentimentos diários guardados em 'daily_sentiments.csv'
Previsões e sentimento guardados em 'predicted_data_with_sentiment.csv'
Erro Absoluto Médio (MAE): 30.66908467315391
Raiz do Erro Quadrático Médio (RMSE): 36.99641752814565
R-quadrado (R2): 0.9257591918098058
Erro Percentual Absoluto Médio (MAPE): 0.00870572230484879
Gráfica guardada como 'ETH_USDT_price_prediction.png'
Gráfica de residuais guardada como 'ETH_USDT_residuals.png'
Correlação entre preços reais e previstos: 0.9752007459642241
Gráfica de estratégia de investimento 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 rendimentos totais: 28
Número de rendimentos em excesso: 28
Número de rendimentos negativos: 19
Média de rendimentos em excesso: 0.005037
Desvio padrão de rendimentos negativos: 0.000000
Sortino Ratio: nan
Beta: 0.33875104783408166
Alpha: 0.006981197358213854
Cross-Validation MAE: 1270.7809910146143 ± 527.5746657573876
Erro Absoluto Médio (MAE) SMA: 344.3737716856061
Erro Absoluto Médio (MAE) SMA: 344.3737716856061
Erro Quadrático Médio (RMSE) SMA: 483.0396130996611
R-quadrado (R2) SMA: 0.5813550203375846
Gráfica de previsão SMA guardada como 'ETH_USDT_sma_price_prediction.png'
Gráfica de preço, previsão e sentimento guardada como 'ETH_USDT_price_prediction_sentiment.png'
Gráfica de drawdown guardada como 'ETH_USDT_drawdown.png'
Máximo Drawdown: 0.00%

Como os resultados indicam, a correlação entre os preços previstos e os reais é muito boa. O R2, que é uma métrica para medir a qualidade das previsões do modelo, também está bom. O Sharpe Ratio é superior a 5, o que é excelente, assim como o Sortino. Além disso, outros resultados são mostrados em gráficos.

O gráfico que compara a estratégia com a manutenção (hold) se parece com isto:

Outros gráficos como previsão de preço vs preço real

e, preço real, previsão de preço e sentimento

Os resultados mostram que esta estratégia é muito lucrativa, então agora estamos usando esse argumento para criar um EA.

Este EA deve ter dois scripts Python que realizam a análise de sentimento e o Modelo de Deep Learning, e deve ser todo integrado para funcionar no EA.

Modelo ONNX

O código para aquisição de dados, treinamento e modelo ONNX permanece o mesmo que usamos em artigos anteriores. Portanto, vou prosseguir para discutir o código Python para análise de sentimento.

Análise de Sentimento com Python

Vamos usar as bibliotecas requests e TextBlob para buscar notícias de forex e realizar a análise de sentimento, juntamente com a biblioteca csv para ler e escrever dados. Além disso, as bibliotecas datetime e time serão utilizadas.

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

A ideia deste script é, primeiro, atrasar por alguns segundos ao iniciar (para garantir que a próxima parte do script funcione corretamente). A segunda parte do script irá ler a chave da API que queremos usar. Para este caso, utilizaremos a API Marketaux, que oferece uma série de notícias gratuitas e chamadas gratuitas. Existem outras opções como News API, Alpha Vantage ou Finhub, algumas das quais são pagas, mas fornecem mais notícias, incluindo notícias históricas, permitindo um backtesting da estratégia no MT5. Como mencionado anteriormente, utilizaremos o Marketaux por enquanto, já que ele possui uma API gratuita para obter notícias diárias. Se quisermos usar outras fontes, precisaremos adaptar o código.

Aqui está um rascunho de como o script poderia ser estruturado:

Aqui está a função para ler a chave da API a partir da entrada do 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 ler as notícias, precisamos saber o que ler, e para isso, faremos com que este script Python leia a partir de um arquivo de texto criado pelo EA, para que o script Python saiba o que ler ou qual símbolo estudar e obter notícias, além da chave da API inserida no EA, qual é a data de hoje para que o modelo seja executado e as notícias cheguem para essa data.

Ele também deve ser capaz de escrever um arquivo .txt ou .csv para servir como entrada para o EA, com os resultados do Sentimento.

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

Os leitores devem adaptar o script inteiro dependendo do que estão estudando, forex, ações ou criptos.

O Expert Advisor

Devemos incluir o shell32.dll como mostrado aqui para rodar os scripts Python.

#include <WinUser32.mqh>

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

Devemos adicionar os scripts Python na pasta de arquivos.

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

E todos os caminhos para as entradas e saídas dos scripts 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 = "_";

Devemos inserir a chave da API Marketaux.

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

Podemos obter isso aqui, e ficará assim:

Não trabalho para o Marketaux, então você pode usar qualquer outro feed de notícias ou assinatura que desejar/precisar.

Você precisará configurar um Número Mágico, para que as ordens não se misturem.

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

Você também pode adicioná-lo aqui.

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

Esse último trecho de código é como a ordem é feita, você também pode usar o trade de CTrade para fazer ordens.

Isso escreverá um arquivo (para ser usado como entrada nos 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());
     }
  }

Isso escreverá o símbolo, o timeframe e a data atual no arquivo:

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
  }

A função WriteSymbolAndTimeframe executa as seguintes tarefas:

1. Primeiro, ela obtém o símbolo de negociação atual e armazena em currentSymbol.
2. Em seguida, obtém o timeframe do gráfico atual como uma string usando GetTimeframeString(Period()) e armazena em currentTimeframe.
3. Ela também obtém a hora atual em um formato específico usando TimeToString(TimeCurrent(), TIME_DATE) e armazena em currentTime.
4. Em seguida, ela escreve cada um desses valores nos respectivos arquivos:
• currentSymbol é escrito no arquivo filePathSymbol.
• currentTimeframe é escrito no arquivo filePathTimeframe.
• currentTime é escrito no arquivo filePathTime.
• api_key é escrito no arquivo filePathApi.
5. Finalmente, a função faz uma pausa de 10 segundos usando Sleep(10000), o que pode ser ajustado ou removido conforme necessário.

Podemos executar os scripts com isso:

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

A função OnTimer é executada periodicamente e realiza as seguintes tarefas:

1. Primeiro, ela obtém a hora atual e armazena em currentTime2.
2. Em seguida, ela verifica se o tempo decorrido desde a última execução do primeiro script (lastExecutionTime1) é maior ou igual a um intervalo predefinido (interval1).
3. Se a condição for atendida, ela escreve os dados necessários chamando WriteSymbolAndTimeframe.
4. Em seguida, ela executa o primeiro script Python, rodando um comando via ShellExecuteW, que abre cmd.exe e executa o script Python especificado por script1.
5. Se a execução do script for bem-sucedida (indicada por um resultado maior que 32), ela imprime uma mensagem de sucesso; caso contrário, imprime uma mensagem de erro com o código de erro correspondente.
6. Finalmente, ela atualiza lastExecutionTime1 para o tempo atual (currentTime2).

Podemos ler o arquivo com esta função:

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

O código define uma função chamada ReadFile, que recebe o nome de um arquivo como argumento e retorna o conteúdo do arquivo como uma string. Primeiro, ele inicializa uma string vazia result, depois tenta abrir o arquivo com permissões de leitura e em modo texto simples usando FileOpen. Se o manipulador de arquivo for válido, ele obtém o tamanho do arquivo com FileSize, lê todo o conteúdo do arquivo em result usando FileReadString e então fecha o arquivo com FileClose. Se o manipulador de arquivo for inválido, ele imprime uma mensagem de erro com o nome do arquivo. Finalmente, retorna result contendo o conteúdo do arquivo.

Alterando esta condição, podemos adicionar o sentimento como mais um:

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

O sentimento, neste caso, varia de 10 a -10, sendo 0 um sinal neutro. Você pode modificar essa estratégia como desejar.

O restante do código é o EA simples usado no artigo Como usar modelos ONNX no MQL5, com algumas modificações.

Este não é um EA completo e finalizado, é apenas um exemplo simples de como usar Python e MQL5 para criar um Expert Advisor de Sentimento & Deep Learning. Quanto mais tempo você investir neste EA, menos erros e problemas aparecerão. Este é um estudo de caso de ponta, e o backtesting mostra resultados promissores. Espero que você ache este artigo útil, e se alguém conseguir obter uma boa amostra de notícias ou fizer com que funcione por algum tempo, por favor, compartilhe os resultados. Para testar a estratégia, você deve usar uma conta demo.

Conclusão

Em conclusão, a integração de deep learning e análise de sentimento nas estratégias de trading do MetaTrader 5 (MQL5) exemplifica as capacidades avançadas do trading algorítmico moderno. Ao aproveitar scripts Python por meio de uma interface DLL shell32.dll, podemos executar modelos complexos de maneira fluida e obter dados valiosos de sentimento, melhorando assim as decisões de trading e os resultados. O processo descrito inclui o uso de Python para buscar e analisar o sentimento das notícias, rodar modelos ONNX para previsões de preços e executar ordens quando ambos os indicadores se alinharem.

Os resultados do backtesting demonstram o potencial de lucratividade da estratégia, conforme indicado por métricas de correlação fortes, altos valores de R-quadrado e excelentes índices de Sharpe e Sortino. Esses achados sugerem que combinar análise de sentimento com deep learning pode melhorar significativamente a precisão dos sinais de trading e o desempenho geral da estratégia.

Seguindo em frente, o desenvolvimento de um Expert Advisor totalmente funcional (EA) envolve a integração cuidadosa de vários componentes, incluindo scripts Python para análise de sentimento e modelos ONNX para previsão de preços. Ao refinar continuamente esses elementos e adaptar a estratégia a diferentes mercados e fontes de dados, os traders podem construir uma ferramenta de trading robusta e eficaz.

Este estudo serve como uma base para aqueles interessados em explorar a convergência de machine learning, análise de sentimento e trading algorítmico, oferecendo um caminho para decisões de trading mais informadas e potencialmente lucrativas.