Integrando modelos de ML ao Testador de Estratégias (Conclusão): Implementação de um Modelo de Regressão para Previsão de Preço

Introdução:

No artigo anterior, finalizamos a implementação da classe de gerenciamento de arquivos CSV para armazenar e recuperar dados relacionados ao mercado financeiro. Com a infraestrutura pronta, estamos aptos a utilizar esses dados para alimentar e treinar um modelo de aprendizado de máquina.

Neste artigo, nosso objetivo é implementar um modelo de regressão que seja capaz de prever o fechamento do preço de um ativo financeiro na semana. Essa previsão nos permitirá analisar o comportamento do mercado e tomar decisões informadas ao negociar ativos financeiros.

A previsão de preços pode ser uma ferramenta útil para desenvolver estratégias de negociação e tomar decisões no mercado financeiro. A capacidade de prever tendências de preços com precisão pode levar a melhores decisões de investimento, maximizando os lucros e minimizando as perdas. Além disso, a previsão de preços pode auxilia na identificação de oportunidades de negociação e na gestão de riscos.

Para implementar nosso modelo de regressão, seguiremos os passos abaixo:

1. Coletar e preparar os dados: utilizaremos script Python recuperar informações sobre preços históricos e outros dados relevantes. Esses dados serão utilizados para treinar e testar nosso modelo de regressão.

2. Selecionar e treinar o modelo: escolheremos um modelo de regressão adequado para o nosso problema e o treinaremos usando os dados coletados. Existem diversos modelos de regressão disponíveis, como regressão linear, regressão polinomial e regressão de suporte vetorial (SVR). A escolha do modelo dependerá de sua adequação ao nosso problema e do desempenho obtido durante o treinamento.

3. Avaliar o desempenho do modelo: para garantir que nosso modelo de regressão está funcionando corretamente, é necessário avaliar seu desempenho em um conjunto de testes. Essa avaliação nos ajudará a identificar possíveis problemas e ajustar o modelo, se necessário.

Ao final deste artigo, teremos um modelo de regressão capaz de prever o fechamento do preço de um ativo financeiro na semana. Essa previsão nos permitirá desenvolver estratégias de negociação mais eficientes e tomar decisões informadas no mercado financeiro.

Seção 1: Seleção do Modelo de Regressão

Antes de implementar nosso modelo de regressão para prever o fechamento do preço de um ativo financeiro na semana, é fundamental entender os diferentes tipos de modelos de regressão disponíveis e suas características. Isso nos permitirá selecionar o modelo mais adequado para o nosso problema. Nesta seção, discutiremos alguns dos modelos de regressão mais comuns utilizados para regressão:

1. Regressão Linear: A regressão linear é um dos modelos de regressão mais simples e amplamente utilizados. Ela assume uma relação linear entre as variáveis independentes e a variável dependente. O objetivo da regressão linear é encontrar a linha reta que melhor se ajusta aos dados, minimizando a soma dos erros quadráticos. Embora seja fácil de entender e implementar, a regressão linear pode não ser adequada para problemas onde a relação entre as variáveis não é linear.

2. Regressão Polinomial: A regressão polinomial é uma extensão da regressão linear que leva em conta as relações não lineares entre as variáveis. Ela utiliza polinômios de diferentes graus para ajustar a curva aos dados. A regressão polinomial pode fornecer uma melhor aproximação para problemas mais complexos; no entanto, é importante evitar o sobreajuste, que ocorre quando o modelo se ajusta demais aos dados de treinamento, comprometendo a capacidade de generalizar para dados não vistos.

3. Regressão de Árvores de Decisão: A regressão de árvores de decisão é um modelo baseado em árvores que divide o espaço de recursos em regiões distintas e não sobrepostas. Em cada região, a previsão é feita com base na média dos valores observados. A regressão de árvores de decisão é capaz de capturar relações complexas e não lineares entre variáveis, mas pode ser propensa a sobreajuste, especialmente se a árvore crescer muito. Técnicas de poda e validação cruzada podem ser utilizadas para combater o sobreajuste.

4. Regressão de Suporte Vetorial (SVR): A regressão de suporte vetorial é uma extensão do algoritmo de máquinas de suporte vetorial (SVM) para problemas de regressão. O SVR tenta encontrar a função que melhor se ajusta aos dados, mantendo a margem máxima entre a função e os pontos de treinamento. O SVR é capaz de modelar relações não lineares e complexas, utilizando funções de kernel, como a função de base radial (RBF). No entanto, o treinamento de um SVR pode ser computacionalmente mais intensivo do que outros modelos de regressão.

Para selecionar o modelo de regressão mais adequado para prever o fechamento do preço de um ativo financeiro na semana, é importante considerar a complexidade do problema e a relação entre as variáveis. Além disso, deve-se levar em conta o equilíbrio entre o desempenho do modelo e a complexidade computacional. Em geral, é recomendável experimentar diferentes modelos e ajustar seus parâmetros para obter o melhor desempenho possível.

Ao selecionar um modelo de regressão, é importante considerar diversos critérios que influenciam a qualidade e a aplicabilidade do modelo. Nesta seção, discutiremos os principais critérios a serem levados em conta durante a seleção do modelo de regressão:

1. Performance: A performance de um modelo de regressão é fundamental para garantir previsões precisas e úteis. Podemos avaliar a performance utilizando métricas como o erro quadrático médio (MSE) e o erro absoluto médio (MAE), entre outras. Ao comparar diferentes modelos, é importante selecionar aquele que apresenta o melhor desempenho em relação a essas métricas.

2. Interpretabilidade: A interpretabilidade de um modelo é a capacidade de entender a relação entre as variáveis e como elas afetam a previsão. Modelos mais simples, como a regressão linear, são geralmente mais fáceis de interpretar do que modelos mais complexos, como as redes neurais. A interpretabilidade é especialmente importante quando se deseja explicar as previsões a outras pessoas ou quando se busca entender os fatores que influenciam os resultados.

3. Complexidade: A complexidade de um modelo de regressão está relacionada ao número de parâmetros e à estrutura do modelo. Modelos mais complexos podem ser capazes de capturar relações mais sutis e não lineares nos dados, mas também podem ser mais propensos ao sobreajuste. É importante equilibrar a complexidade do modelo com a capacidade de generalização para dados não vistos.

4. Tempo de Treinamento: O tempo de treinamento é um aspecto importante a ser considerado, especialmente quando se trabalha com grandes conjuntos de dados ou quando se deseja treinar modelos iterativamente. Modelos mais simples, como a regressão linear e polinomial, geralmente requerem menos tempo de treinamento do que modelos mais complexos, como as redes neurais ou regressão de suporte vetorial. É crucial encontrar um equilíbrio entre o desempenho do modelo e o tempo de treinamento para garantir que o modelo seja aplicável em tempo hábil.

5. Robustez: A robustez de um modelo de regressão refere-se à sua capacidade de lidar com outliers e ruídos nos dados. Modelos robustos são menos sensíveis a pequenas variações nos dados e podem fornecer previsões mais estáveis. É importante selecionar um modelo que seja capaz de lidar com a presença de outliers e ruídos nos dados.

Ao selecionar o modelo de regressão mais adequado para prever o fechamento do preço, é importante ponderar esses critérios e encontrar o equilíbrio adequado entre eles. Experimentar diferentes modelos e ajustar seus parâmetros para otimizar o desempenho é uma estratégia recomendada para garantir a escolha do melhor modelo para o problema em questão.

Com base nos critérios mencionados anteriormente, optamos por utilizar o modelo de regressão de árvores de decisão (Decision Tree Regression) para prever o fechamento do preço. A escolha deste modelo é justificada pelos seguintes motivos:

1. Performance: As árvores de decisão geralmente apresentam bom desempenho em problemas de regressão, sendo capazes de capturar relações não lineares e interações entre variáveis. Ao ajustar corretamente os hiperparâmetros do modelo, como a profundidade da árvore e o número mínimo de amostras por folha, podemos obter um equilíbrio entre ajuste e generalização.

2. Interpretabilidade: Uma das vantagens das árvores de decisão é sua interpretabilidade. As árvores de decisão representam uma série de decisões baseadas em atributos e seus valores, tornando-se fácil de entender e explicar. Isso é útil para justificar as previsões e entender os fatores que influenciam o fechamento do preço.

3. Complexidade: A complexidade das árvores de decisão pode ser controlada ajustando-se os hiperparâmetros do modelo. Isso permite encontrar um equilíbrio entre a capacidade de modelar relações complexas e a simplicidade do modelo, evitando o sobreajuste.

4. Tempo de Treinamento: As árvores de decisão geralmente têm tempos de treinamento relativamente rápidos em comparação com outros modelos mais complexos, como redes neurais ou máquinas de suporte vetorial. Isso torna o modelo de regressão de árvores de decisão adequado para casos em que o tempo de treinamento é um fator relevante.

5. Robustez: As árvores de decisão são robustas a ruídos e outliers nos dados, já que cada decisão é baseada em um conjunto de amostras e não em uma única observação. Isso contribui para a estabilidade das previsões e a confiabilidade do modelo.

Considerando os critérios discutidos e as vantagens oferecidas pela regressão de árvores de decisão, acredito que que este modelo de exemplo é uma escolha adequada para prever o fechamento do preço semanal. No entanto, é importante lembrar que a seleção de modelos pode variar de acordo com o contexto e os requisitos específicos de cada problema. Experimentar e comparar diferentes modelos de regressão pode ser útil para garantir a escolha do modelo mais apropriado.

Seção 2: Preparação dos Dados

A preparação e limpeza dos dados são etapas cruciais no processo de implementação de um modelo de regressão, pois a qualidade dos dados de entrada tem um impacto direto na eficácia e no desempenho do modelo. Essas etapas são fundamentais pelos seguintes motivos:

1. Remoção de ruídos e outliers: Dados brutos podem conter ruídos, erros e outliers que podem afetar adversamente a performance do modelo. Ao identificar e tratar essas discrepâncias, é possível melhorar a qualidade dos dados e, consequentemente, a precisão das previsões.

2. Preenchimento e exclusão de valores ausentes: Dados incompletos são comuns em conjuntos de dados, e a ausência de valores pode levar a um desempenho insatisfatório do modelo. Imputar valores ausentes, excluir registros com dados faltantes ou utilizar técnicas específicas para lidar com dados faltantes são essenciais para garantir a integridade e confiabilidade dos dados. A escolha entre imputação e exclusão de valores ausentes dependerá da natureza dos dados, da quantidade de valores ausentes e do impacto potencial desses valores no desempenho do modelo. É importante analisar cuidadosamente cada situação e escolher a abordagem mais adequada para o problema em questão.

3. Seleção de variáveis: Nem todas as variáveis disponíveis em um conjunto de dados podem ser relevantes ou úteis para a previsão do fechamento do preço. A seleção adequada das variáveis permite que o modelo se concentre nas características mais relevantes, melhorando a performance e reduzindo a complexidade do modelo.

4. Transformação de dados: Algumas vezes, os dados brutos precisam ser transformados para se adequarem às suposições do modelo de regressão ou para melhorar a relação entre as variáveis independentes e a variável dependente. Exemplos de transformações incluem normalização, padronização e aplicação de funções matemáticas, como logaritmo ou raiz quadrada.

5. Divisão dos dados: É importante dividir o conjunto de dados em subconjuntos de treinamento e teste para avaliar adequadamente a performance do modelo de regressão. Essa divisão permite treinar o modelo com um subconjunto de dados e testar sua capacidade de generalizar para dados não vistos, fornecendo uma estimativa do desempenho do modelo em situações reais.

Dedicar tempo e esforço para a preparação e limpeza dos dados é uma etapa vital no processo de implementação de um modelo de regressão, pois garante que o modelo seja treinado e avaliado com base em informações de qualidade, maximizando sua eficácia e utilidade na previsão do fechamento do preço.

Farei um exemplo básico de preparação de dados para um modelo de regressão utilizando Python. No entanto, é fundamental enfatizar a importância de aprofundar seus conhecimentos sobre esse tema, pois cada conjunto de dados e problema podem exigir abordagens e técnicas específicas de limpeza e preparação. Portanto, é altamente recomendável que você invista tempo em estudar e entender os diferentes métodos e técnicas envolvidos na preparação de dados.

Para coletar os dados iremos usar a função get_rates_between  que foi construída para facilitar a coleta de dados financeiros de um ativo específico em um determinado período. Ela utiliza a biblioteca MetaTrader 5 (mt5) para se conectar a uma plataforma de negociação e obter informações históricas de preço em diferentes intervalos de tempo.

A função tem os seguintes parâmetros:

• symbol: uma string que representa o símbolo do ativo financeiro (por exemplo, "PETR3", "EURUSD", ).
• period: um inteiro que indica o período de tempo dos dados a serem coletados (por exemplo, mt5.TIMEFRAME_W1 para dados semanais).
• ini: um objeto datetime que representa a data e hora iniciais do intervalo de tempo para coletar os dados.
• end: um objeto datetime que representa a data e hora finais do intervalo de tempo para coletar os dados.

A função começa verificando se o MetaTrader 5 foi inicializado corretamente. Se a inicialização falhar, a função retorna uma exceção e encerra o programa.

Em seguida, a função usa a função mt5.copy_rates_range()para obter os dados financeiros do ativo e período especificados. Os dados são armazenados em um objeto DataFrame do pandas, que é uma estrutura de dados bidimensional rotulada com eixos, adequada para armazenar dados financeiros.

Depois de obter os dados, a função verifica se o DataFrame está vazio. Se estiver, a função retorna uma exceção, pois isso indica um erro ao coletar os dados.

Se tudo correr bem, a função converte a coluna 'time' do DataFrame para um formato legível de data e hora, usando a função pd.to_datetime(). A coluna 'time' é então definida como o índice do DataFrame, o que facilita o acesso e a manipulação dos dados.

def get_rates_between(symbol:str, period : int, ini : datetime, end : datetime):
    if not mt5.initialize():
        print("initialize() failed")
        mt5.shutdown()
        raise Exception("Error Getting Data")

    rates = mt5.copy_rates_range(symbol, period, ini, end)
    mt5.shutdown()
    rates = pd.DataFrame(rates)

    if rates.empty:
        raise Exception("Error Getting Data")

    rates['time'] = pd.to_datetime(rates['time'], unit='s')
    rates.set_index(['time'], inplace=True)

    return rates

Neste exemplo, estaremos utilizando dados financeiros para o par de moedas EUR/USD no período semanal, abrangendo de 1º de janeiro de 2000 a 31 de dezembro de 2022. Para isso, utilizaremos a função get_rates_between . Primeiro, importe as bibliotecas necessárias:

import pandas as pd
from datetime import datetime, timezone
import MetaTrader5 as mt5
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

Em seguida, defina as informações do ativo financeiro que deseja analisar:

symbol = "EURUSD"
date_ini = datetime(2000, 1, 1, tzinfo=timezone.utc)
date_end = datetime(2022, 12, 31, tzinfo=timezone.utc)
period = mt5.TIMEFRAME_W1

Agora, você pode chamar a função get_rates_between usando as informações definidas anteriormente:

df = get_rates_between(symbol=symbol, period=period, ini=date_ini, end=date_end)

Após a obtenção dos dados, o próximo passo é preparar esses dados para o desenvolvimento de um modelo de aprendizado de máquina. Essa preparação inclui a remoção de ruídos e outliers, seleção de variáveis, transformação de dados e divisão dos dados em conjuntos de treinamento e teste. Vamos detalhar cada etapa.

Remoção de ruídos e outliers:

O primeiro passo é remover ruídos e outliers dos dados. Ruídos são variações aleatórias e indesejadas nos dados que podem dificultar a identificação de padrões. Outliers são valores que diferem significativamente dos outros valores do conjunto de dados. Ambos podem prejudicar o desempenho do modelo.

Existem várias técnicas para remover ruídos e outliers. Neste artigo, usaremos a técnica de alisamento exponencial, que atribui um peso exponencialmente decrescente aos dados mais recentes, ajudando a suavizar as variações. Para isso, utilizaremos a função ewm do pandas.

smoothed_df = df.ewm(alpha=0.1).mean()

Seleção de variáveis

O próximo passo é selecionar as variáveis que serão utilizadas como features e target. Neste exemplo, usaremos o preço de abertura (open), o indicador MACD (Moving Average Convergence Divergence) e a média móvel exponencial (EMA) como features. O preço de fechamento (close) será utilizado como target.

# Função para calcular o MACD
def macd(df, fast_period=12, slow_period=26, signal_period=9):
    ema_fast = df['close'].ewm(span=fast_period).mean()
    ema_slow = df['close'].ewm(span=slow_period).mean()
    macd_line = ema_fast - ema_slow
    signal_line = macd_line.ewm(span=signal_period).mean()
    return macd_line, signal_line

# Função para calcular a EMA
def ema(df, period=30):
    return df['close'].ewm(span=period).mean()

# Calculando o MACD e a linha de sinal
smoothed_df['macd'], smoothed_df['signal'] = macd(smoothed_df)

# Calculando a EMA
smoothed_df['ema'] = ema(smoothed_df)

# Selecionando as variáveis
selected_df = smoothed_df[['open', 'macd', 'ema', 'close']].dropna()

Transformação de dados

A transformação de dados é importante para garantir que as variáveis estejam na mesma escala e possam ser comparadas de maneira justa. Neste exemplo, utilizaremos a normalização Min-Max, que transforma os dados para uma escala entre 0 e 1.

scaler = MinMaxScaler()
normalized_df = pd.DataFrame(scaler.fit_transform(selected_df), columns=selected_df.columns, index=selected_df.index)

Divisão dos dados

Por fim, dividiremos os dados em conjuntos de treinamento e teste. O conjunto de treinamento será usado para treinar o modelo, enquanto o conjunto de teste será usado para avaliar seu desempenho.

X = normalized_df[['open', 'macd', 'ema']]
y = normalized_df['close']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

Na seção 2, realizamos várias etapas importantes para garantir que os dados estejam prontos para serem usados em um modelo de aprendizado de máquina.

Começamos por carregar os dados do ativo financeiro usando a API do MetaTrader5, convertendo-os em um DataFrame pandas e ajustando a coluna de tempo para ser usada como índice. Em seguida, realizamos a limpeza dos dados, eliminando qualquer valor ausente e verificando a presença de outliers e dados inconsistentes. Essa limpeza é fundamental para garantir que o modelo não seja afetado por valores inválidos ou não relevantes.

Optamos por selecionar as variáveis que seriam utilizadas como feature e target do modelo, escolhendo Open, MACD e EMA como features e Close como o target. Contudo, cabe ressaltar que tal seleção foi realizada de forma aleatória, com o propósito de fornecer um exemplo ilustrativo.

Realizamos a normalização dos dados, que é importante para evitar que as diferenças nas escalas dos dados afetem o modelo de aprendizado de máquina. E por fim, dividimos os dados em um conjunto de treinamento e um conjunto de teste, para avaliar a capacidade do modelo de generalizar para novos dados.

Essas etapas de preparação dos dados são cruciais para garantir que o modelo seja preciso e eficaz em suas previsões. Uma vez que os dados estão preparados, podemos prosseguir para a próxima etapa, que é a criação e treinamento do modelo de aprendizado de máquina.

Seção 3: Treinamento e Avaliação do Modelo de Regressão com Árvore de Decisão

Com os conjuntos de treinamento e teste criados e os dados devidamente preparados, estamos prontos para criar, treinar e avaliar nosso modelo de regressão com árvore de decisão. A árvore de decisão é um método de aprendizado supervisionado que pode ser aplicado tanto a problemas de classificação quanto de regressão. Neste caso, utilizaremos a árvore de decisão para prever o preço de fechamento de um ativo financeiro.

• Importar bibliotecas e criar o modelo

Começamos importando as bibliotecas necessárias e criando uma instância do modelo DecisionTreeRegressor do scikit-learn.

from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, r2_score

regressor = DecisionTreeRegressor(random_state=42)

• Treinar o modelo

Em seguida, treinamos o modelo usando o conjunto de treinamento (X_train e y_train).

regressor.fit(X_train, y_train)

• Fazer previsões

Com o modelo treinado, podemos fazer previsões no conjunto de teste (X_test) e comparar os resultados com os valores reais do conjunto de teste (y_test).

y_pred = regressor.predict(X_test)

• Avaliar o desempenho do modelo

Avaliar o desempenho do modelo é fundamental para entender quão bem ele está se ajustando aos dados e realizando previsões. Além do erro quadrático médio (MSE) e do coeficiente de determinação (R²), podemos utilizar outras métricas para avaliar o desempenho do nosso modelo de regressão com árvore de decisão. Algumas métricas adicionais que podemos considerar incluem:

• Erro absoluto médio (MAE): O MAE é a média das diferenças absolutas entre as previsões e os valores reais. É uma métrica fácil de entender e fornece uma medida de quão longe as previsões estão dos valores reais.
• Erro percentual absoluto médio (MAPE): O MAPE é a média dos erros percentuais absolutos entre as previsões e os valores reais. Essa métrica fornece uma medida do desempenho do modelo em termos percentuais, o que pode ser útil ao comparar modelos com diferentes escalas de valores.
• Raiz do erro quadrático médio (RMSE): O RMSE é a raiz quadrada do MSE. Essa métrica tem a vantagem de estar na mesma unidade que a variável de destino, o que facilita a interpretação dos resultados.

Para calcular essas métricas adicionais, você pode usar a biblioteca Scikit-learn. Primeiro, importe as funções necessárias:

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

Em seguida, calcule as métricas usando as previsões e os valores reais:

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

Agora você pode exibir os resultados:

print(f"MAE: {mae:.4f}")
print(f"MSE: {mse:.4f}")
print(f"RMSE: {rmse:.4f}")
print(f"R²: {r2:.4f}")

• Ajustar e otimizar o modelo

Dependendo dos resultados obtidos, pode ser necessário ajustar e otimizar o modelo. Isso pode ser feito ajustando os hiperparâmetros da árvore de decisão, como a profundidade máxima (max_depth), o número mínimo de amostras necessárias para dividir um nó interno (min_samples_split) e o número mínimo de amostras necessárias para estar em um nó folha (min_samples_leaf), entre outros.

Para otimizar os hiperparâmetros, podemos utilizar técnicas como a busca em grade (GridSearchCV) ou a busca aleatória (RandomizedSearchCV) do scikit-learn. Essas técnicas permitem testar várias combinações de hiperparâmetros e encontrar a melhor configuração para o modelo.

from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeRegressor


regressor = DecisionTreeRegressor(random_state=42)

param_grid = {
    'max_depth': [3, 4, 5, 6, 7, 8],
    'min_samples_split': [2, 3, 4],
    'min_samples_leaf': [1, 2, 3]
}

grid_search = GridSearchCV(estimator=regressor, param_grid=param_grid, scoring='neg_mean_squared_error', cv=5, n_jobs=-1)
grid_search.fit(X_train, y_train)

best_params = grid_search.best_params_
print(f"Melhores hiperparâmetros: {best_params}")

best_regressor = DecisionTreeRegressor(**best_params, random_state=42)
best_regressor.fit(X_train, y_train)

y_pred_optimized = best_regressor.predict(X_test)

mae_optimized = mean_absolute_error(y_test, y_pred_optimized)
mse_optimized = mean_squared_error(y_test, y_pred_optimized)
rmse_optimized = np.sqrt(mse_optimized)
r2_optimized = r2_score(y_test, y_pred_optimized)

print(f"MAE otimizado: {mae_optimized:.4f}")
print(f"MSE otimizado: {mse_optimized:.4f}")
print(f"RMSE otimizado: {rmse_optimized:.4f}")
print(f"R² otimizado: {r2_optimized:.4f}")

• Desnormalizar os preços e criar um gráfico
  

Para desnormalizar os preços e criar um gráfico, você pode usar o inverse_transform do MinMaxScaler. Primeiro, desnormalize o preço real (y_test) e o preço previsto (y_pred_optimized), e então crie um gráfico usando a biblioteca matplotlib. Aqui está o código atualizado:

import matplotlib.pyplot as plt

# Função para desnormalizar os preços
def denormalize_price(scaler, normalized_price, column_name):
    dummy_df = pd.DataFrame(np.zeros((len(normalized_price), len(selected_df.columns))), columns=selected_df.columns)
    dummy_df[column_name] = normalized_price
    denormalized_df = scaler.inverse_transform(dummy_df)
    return denormalized_df[:, selected_df.columns.get_loc(column_name)]

# Desnormalizar os preços reais e previstos
y_test_denorm = denormalize_price(scaler, y_test, 'close')
y_pred_optimized_denorm

Esta seção conclui a implementação de um modelo de regressão com árvore de decisão para prever o fechamento do preço de um ativo financeiro. Ao treinar e avaliar o modelo, obtivemos métricas de desempenho e ajustamos os hiperparâmetros para otimizar seu desempenho.

No entanto, é importante destacar que este exemplo é apenas uma abordagem básica, e existem muitas técnicas e estratégias avançadas disponíveis para melhorar a precisão e o desempenho do modelo. Além disso, a escolha do modelo de regressão e a preparação dos dados podem variar dependendo do contexto e dos requisitos específicos de cada problema.

Por fim, é fundamental ressaltar a importância de testar, validar e iterar o modelo em diferentes cenários e conjuntos de dados, a fim de garantir que ele seja robusto e confiável na previsão de preços no mercado financeiro.

Seção 4: Integrando o Modelo de Regressão ao Testador de Estratégias

Nesta seção, vamos explorar em detalhes a ideia de construir um sistema que permite testar um modelo Python diretamente no Strategy Tester do MetaTrader. Esta abordagem acrescentará uma camada adicional de flexibilidade à criação de modelos, aproveitando a simplicidade do Python. O processo de validação ocorrerá no próprio MetaTrader, pois o modelo será exportado em formato ONNX para o MQL5. Isso significa que você poderá moldar e aprimorar seu modelo com facilidade, enquanto a validação rigorosa acontece no ambiente MetaTrader, garantindo que ele esteja pronto para enfrentar as complexidades do mercado financeiro.

Comunicação Eficiente entre Python e MQL5

No centro deste sistema, surge a necessidade crucial de estabelecer uma comunicação eficaz entre o Python e o MQL5. Para atingir esse objetivo, será criada uma classe em Python que simplificará a troca de mensagens com o Testador de Estratégias do MQL5. Enquanto o programa Python estiver em execução, ele monitorará atentamente as operações realizadas no Testador de Estratégias, transmitindo prontamente os dados de preços do ativo para o Python assim que o Testador for iniciado. Esse fluxo constante de informações é essencial para fornecer dados em tempo real ao modelo de regressão, permitindo, portanto, que ele tome decisões baseadas nesses dados. Além disso, é importante lembrar da implementação em MQL5 de uma classe que facilite a manipulação de arquivos CSV, conforme explicado neste artigo.

Construção da Classe File para Comunicação entre Python e MQL5

A classe File desempenha um papel crucial na comunicação eficaz entre Python e o Testador de Estratégias do MQL5. Vamos analisar as principais funcionalidades dessa classe, que simplifica a troca de dados e a manipulação de arquivos entre essas duas linguagens.

Inicialização da Classe

A classe File é projetada como um Singleton, garantindo que haja apenas uma instância dela em todo o programa. Isso é importante para manter a integridade da comunicação entre Python e MQL5.

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

Verificação e Manipulação de Arquivos

A classe File fornece métodos essenciais para verificar a existência de arquivos, lidar com erros associados a arquivos e realizar operações de leitura e gravação.

• O método __init_file verifica se um arquivo existe. Se o arquivo não existir, ele aguarda por um segundo antes de retornar False . Isso é útil para garantir que o arquivo esteja pronto para ser acessado.

• O método __handle_error lida com exceções que podem ocorrer ao interagir com arquivos. Ele identifica erros comuns, como PermissionError e FileNotFoundError , e fornece informações detalhadas sobre esses erros.

• Os métodos check_init_param e check_open_file são fundamentais para ler arquivos CSV. O primeiro verifica se o arquivo existe e, em caso afirmativo, lê o arquivo e retorna um valor específico da coluna typerun do DataFrame. O segundo método verifica a existência do arquivo e o lê como um DataFrame completo.

from pathlib import Path
from time import sleep
from typing import Tuple
import pandas as pd
from pandas.core.frame import DataFrame
import os
from errno import EACCES, EPERM, ENOENT
import sys

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

CSV_SEPARATOR = ';'

class File(metaclass=Singleton):

    def __init__(self) -> None:
        pass

    def __init_file(self, name_arq: str) -> bool:
        return Path(name_arq).is_file() or sleep(1) or False

    def __handle_error(self, e, name_arq: str):
        ERRORS = {
            EPERM: "PermissionError",
            EACCES: "PermissionError",
            ENOENT: "FileNotFoundError"
        }
        print(f"{ERRORS.get(e.errno, 'Unknown error')} error({e.errno}): {e.strerror} for:\n{name_arq}")

    def check_init_param(self, name_arq : str) -> Tuple[str]:
        while True:
            try:
                if self.__init_file(name_arq):
                    df = pd.read_csv(name_arq, sep=CSV_SEPARATOR)
                    return (df.typerun.values[0])
            except (IOError, OSError) as e:
                self.__handle_error(e, name_arq)
            except:
                print('Unexpected error:', sys.exc_info()[0])

    def check_open_file(self, name_arq: str) -> pd.DataFrame():
        while True:
            try:
                if self.__init_file(name_arq):
                    return pd.read_csv(name_arq, sep=CSV_SEPARATOR)
            except (IOError, OSError) as e:
                self.__handle_error(e, name_arq)
            except:
                print('Unexpected error:', sys.exc_info()[0])

    @staticmethod
    def save_file_csv(name_arq: str, dataset:DataFrame = pd.DataFrame({'col':['ok']})):
        dataset.to_csv(name_arq, sep=CSV_SEPARATOR)

    @staticmethod
    def save(name_arq:str, data:str):
        with open(name_arq, 'w') as f:
            f.write(data)

    @staticmethod
    def delete_file(name_arq: str):
        try:
            os.remove(name_arq)
        except:
            pass

Salvando e Excluindo Arquivos

A classe File também facilita a tarefa de salvar e excluir arquivos.

• O método save_file_csv permite que você salve um DataFrame em um arquivo CSV. Isso é útil quando você deseja armazenar dados em um formato acessível para análises futuras.

• O método save é usado para salvar dados em um arquivo de texto. Isso é útil quando você precisa armazenar informações simples em um formato legível.

• O método delete_file fornece uma maneira simples de excluir um arquivo do sistema.

Processamento de Dados no Python

No lado do Python, o programa recebe os dados de preços do ativo e executa uma série de etapas de pré-processamento. Essas etapas são essenciais para garantir que os dados estejam prontos para serem usados pelo modelo de regressão. Vamos dar uma olhada mais detalhada em como isso funciona:

1. Normalização dos Dados: Um passo inicial envolve a normalização dos dados. Isso significa ajustar os valores para que eles estejam em uma faixa específica, geralmente entre 0 e 1. A normalização é vital para garantir que diferentes características (como preços de ações e volumes de negociação) estejam na mesma escala, evitando assim qualquer viés no modelo.

2. Detecção e Eliminação de Valores Discrepantes: Os dados financeiros podem ser voláteis, e valores discrepantes (outliers) podem distorcer os resultados do modelo. O programa Python detecta e, quando apropriado, remove esses valores discrepantes para garantir a qualidade dos dados de entrada.

3. Criação de Características Adicionais: Em muitos casos, características adicionais são criadas a partir dos dados originais. Isso pode incluir médias móveis, indicadores técnicos, ou outras métricas que o modelo pode usar para tomar decisões mais informadas.

Somente após o preparo completo dos dados é que o modelo de regressão entra em ação.

O Modelo de Regressão em Ação

O modelo de regressão, que pode ser uma Regressão Linear, Regressão de Árvore de Decisão ou outro modelo apropriado, já foi treinado previamente com base em dados históricos. Agora, ele é carregado no programa Python e empregado para realizar previsões com base nos dados de preços mais recentes. Essas previsões são fundamentais para a tomada de decisões de negociação, pois fornecem insights valiosos sobre o comportamento futuro do ativo. Vale ressaltar que, embora neste exemplo estejamos usando um modelo de regressão específico, como uma Regressão Linear, essa abordagem pode ser aplicada a uma variedade de modelos, como redes neurais, algoritmos de árvore de decisão e outros, dependendo dos requisitos específicos de sua estratégia de negociação. Portanto, a flexibilidade desse sistema permite a incorporação de modelos diversificados para atender às necessidades individuais de cada estratégia.

Integração ONNX para Aprimorar o MetaTrader 5

Quero compartilhar uma dica interessante que pode melhorar nosso sistema no MetaTrader 5: a integração com o ONNX (Open Neural Network Exchange). O ONNX é uma ferramenta muito amigável para a inteligência artificial, que torna a transferência de modelos para o MetaTrader 5 muito mais fácil.

Após realizar testes rigorosos e confirmar a eficácia do nosso modelo no MetaTrader 5, podemos considerar a opção de exportá-lo para o formato ONNX. Isso não apenas aprimora as capacidades do MetaTrader 5, mas também facilita a utilização desse modelo em diversas estratégias e sistemas dentro da plataforma.

Com a integração nativa do ONNX no MetaTrader 5, essa dica oferece oportunidades empolgantes para aprimorar ainda mais a utilização de modelos em nossas estratégias de negociação na plataforma.

Testes Exaustivos antes da Exportação

A escolha de nossa abordagem atual, que envolve a interação com o ambiente MQL5, está fundamentada na necessidade de realizar testes extensivos em um ambiente controlado antes de proceder com a exportação do modelo para o formato ONNX. A construção e a integração direta de modelos dentro do MQL5 podem se revelar processos intrincados e suscetíveis a equívocos. Assim, essa metodologia nos possibilita aprimorar e ajustar os modelos de maneira meticulosa, garantindo que alcancem o desempenho desejado, antes de serem efetivamente exportados para o formato ONNX.

Conclusão

Em resumo, este artigo explorou uma abordagem abrangente para a implementação de um modelo de regressão. Na Seção 1, discutimos a seleção do modelo de regressão, enfocando a importância de escolher o algoritmo adequado para o problema em questão. Na Seção 2, abordamos a preparação dos dados, destacando a necessidade de processar e limpar os dados para garantir que estejam prontos para o treinamento do modelo.

Na Seção 3, focamos no treinamento e avaliação do modelo de regressão, utilizando a Árvore de Decisão como exemplo. Explicamos a importância de dividir os dados em conjuntos de treinamento e teste, bem como de ajustar hiperparâmetros para otimizar o desempenho do modelo.

Finalmente, na Seção 4, exploramos a integração do modelo de regressão no Testador de Estratégias do MetaTrader, realçando a necessidade de comunicação eficiente entre Python e MQL5, além de destacar a possibilidade de usar o formato ONNX para melhorar a implementação no MetaTrader 5.

Em resumo, este artigo forneceu uma visão geral das etapas essenciais para incorporar modelos em estratégias de negociação, destacando a importância da escolha adequada do modelo, da preparação de dados, do treinamento e avaliação, e da integração eficaz no ambiente de negociação. Essas etapas formam a base para criar sistemas de negociação mais robustos e informados por dados.
O código mencionado está disponível no repositório do Git para referência adicional.