Desenvolvimento de robô em Python e MQL5 (Parte 3): Implementação do algoritmo de negociação baseado em modelo

No primeiro artigo da série, carregamos o dataset, marcamos, enriquecemos e rotulamos o dataset. O segundo artigo da série focou na criação e no treinamento do modelo, implementação de validação cruzada e bagging. 

Agora que o nosso modelo está treinado e validado, é hora de começar a negociação real usando a biblioteca MetaTrader 5 para Python. Esta poderosa biblioteca nos permite automatizar a negociação diretamente através do Python, utilizando as funções e classes fornecidas pela plataforma MetaTrader 5.

Implementação do algoritmo de negociação baseado em modelo

Para implementar o algoritmo de negociação com base no nosso modelo, seguiremos a abordagem a seguir. O algoritmo principal consiste em abrir negociações com stop loss e take profit predefinidos que correspondem aos rótulos gerados pelo modelo. Se o modelo prever que o preço do ativo aumentará, abrimos uma posição longa com níveis definidos de stop loss e take profit. Se o modelo prever uma queda de preço, abrimos uma posição curta com parâmetros semelhantes de stop loss e take profit.

A biblioteca MetaTrader 5 para Python fornece as ferramentas necessárias para gerenciar a abertura e fechamento de negociações, bem como a configuração dos níveis de stop loss e take profit. Isso nos permite automatizar totalmente o processo de negociação com base nas previsões do nosso modelo.

Usando os dados obtidos nas etapas anteriores de análise e treinamento, podemos, em tempo real, enviar sinais para abrir e fechar posições na plataforma MetaTrader 5, garantindo assim a continuidade e a precisão do nosso algoritmo de negociação.

Dessa forma, a integração do nosso modelo treinado com a biblioteca MetaTrader 5 para Python nos permite criar um algoritmo de negociação eficiente e automatizado, que realiza operações com base nas previsões do modelo, gerenciando riscos com stops loss definidos e protegendo lucros com take profits.

Configuração do ambiente, terminal de negociação e execução do algoritmo

Para começar, é necessário configurar o ambiente e o terminal de negociação MetaTrader 5. Siga estes passos:

Instale as bibliotecas para Python usando o comando pip:

pip install numpy pandas MetaTrader5 scikit-learn xgboost

Nas referências ao terminal, indique o caminho para o arquivo executável do terminal:

terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

Escrevendo negociação online

Para implementar a negociação online, vamos escrever a função online_trading, que abrirá negociações de acordo com a previsão do nosso modelo.

A função online_trading aceita os seguintes argumentos:

• symbol: o símbolo do instrumento que será negociado
• features: a lista de características que serão usadas para a previsão
• model: o modelo treinado que será usado para a previsão

Dentro da função online_trading, conectamos primeiro ao terminal MetaTrader 5, usando o caminho especificado em terminal_path. Em seguida, obtemos os preços atuais do instrumento usando a função mt5.symbol_info_tick(symbol).

Depois, utilizamos o nosso modelo para prever o sinal com base nas características fornecidas. Se a previsão for positiva (maior que 0,5), abrimos uma posição longa, e se a previsão for negativa (menor que 0,5), abrimos uma posição curta.

Também configuramos stop loss e take profit para cada negociação, com o objetivo de minimizar os riscos.

Se já tivermos atingido o número máximo de negociações abertas (definido na constante MAX_OPEN_TRADES), não abriremos novas negociações e aguardaremos até que uma das negociações abertas seja fechada.

Se a previsão não permitir abrir uma nova negociação, aguardamos até que um novo sinal apareça.

No final da função, retornamos o resultado da execução da negociação, caso ela tenha sido aberta com sucesso, ou None se a negociação não tiver sido aberta.

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": 0.3,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": 0.3,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

def process_symbol(symbol):
    try:
        # Retrieve data for the specified symbol
        raw_data = retrieve_data(symbol)
        if raw_data is None:
            print("Данные для символа {} не найдены".format(symbol))
            return None

        # Augment data
        augmented_data = augment_data(raw_data)

        # Markup data
        marked_data = markup_data(augmented_data.copy(), 'close', 'label')

        # Label data
        labeled_data = label_data(marked_data, symbol)

        # Generate new features
        labeled_data_generate = generate_new_features(labeled_data, num_features=100, random_seed=1)

        # Cluster features by GMM
        labeled_data_clustered = cluster_features_by_gmm(labeled_data_generate, n_components=4)

        # Feature engineering
        labeled_data_engineered = feature_engineering(labeled_data_clustered, n_features_to_select=10)

        # Train XGBoost classifier
        train_data = labeled_data_engineered[labeled_data_engineered.index <= FORWARD]

Execução do algoritmo de negociação online

Para executar o algoritmo de negociação online, chamamos a função process_symbol, passando o símbolo do instrumento que será negociado.

Dentro da função process_symbol, chamamos a função online_trading, fornecendo os argumentos necessários, e iniciamos um ciclo que continuará executando até ser interrompido.

No final do ciclo, fazemos uma pausa de 6 segundos para não sobrecarregar o terminal MetaTrader 5.

Se ocorrer um erro durante a execução do algoritmo, exibimos uma mensagem de erro e interrompemos a execução.

Sistema inteligente de gerenciamento de riscos e rebaixamento

A gestão de riscos é um pilar essencial de uma estratégia de negociação bem-sucedida. Um dos principais riscos enfrentados pelos traders é o risco de rebaixamento, quando os preços dos ativos caem abaixo de um nível previamente definido. Para minimizar esse risco, é necessário um sistema eficiente de gerenciamento de riscos que possa se adaptar às mudanças nas condições do mercado.

Desenvolveremos um sistema que reduz automaticamente o volume de negociações em caso de rebaixamento do saldo da conta, utilizando as ferramentas da biblioteca MetaTrader 5 para Python.

As principais regras do sistema são as seguintes:

1. Obtenção diária do saldo atual da conta: todos os dias, o sistema obterá o saldo atual da conta para analisar as mudanças.

2. Redução do volume de negociações em caso de rebaixamento: se o saldo cair mais de 2% em um dia, o sistema reduzirá automaticamente o volume de negociações abertas em 10%. Isso é feito com um incremento de 0,01 lote para reduzir gradualmente os riscos.

3. Redução adicional do volume caso o rebaixamento continue: se o rebaixamento continuar, o volume de negociações será reduzido diariamente em mais 10% e 0,01 lote, garantindo proteção adicional ao capital.

4. Retorno ao volume original após recuperação do saldo: quando o saldo atual da conta exceder o pico anterior, o sistema restaurará automaticamente o volume de negociações ao valor original. Isso ajuda a retomar a atividade total de negociação após uma redução temporária devido ao rebaixamento.

Na função online_trading, foram adicionadas novas variáveis: account_balance para armazenar o saldo atual, peak_balance para armazenar o nível de saldo máximo anterior, e daily_drop para monitorar o rebaixamento diário. Essas variáveis são usadas para implementar a lógica de gerenciamento de riscos.

Exemplo de código:

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    # Get the current account balance
    account_info = mt5.account_info()
    account_balance = account_info.balance

    # Set the initial volume for opening trades
    volume = 0.3

    # Set the initial peak balance
    peak_balance = account_balance

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        # Calculate the daily drop in account balance
        account_info = mt5.account_info()
        current_balance = account_info.balance
        daily_drop = (account_balance - current_balance) / account_balance

        # Reduce the volume for opening trades by 10% with a step of 0.01 lot for each day of daily drop
        if daily_drop > 0.02:
            volume -= 0.01
            volume = max(volume, 0.01)
        elif current_balance > peak_balance:
            volume = 0.3
            peak_balance = current_balance

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

Implementação do gerenciamento de volume pelo critério de Kelly

O gerenciamento de volume é outro aspecto essencial do controle de riscos na negociação. Um dos métodos populares de gerenciamento de volume é o critério de Kelly. O critério de Kelly é uma fórmula matemática que ajuda a determinar o tamanho ideal da aposta, com base na probabilidade de vitória e na relação de ganho/perda.

Neste artigo, vamos mostrar como integrar o gerenciamento de volume usando o critério de Kelly em nosso sistema de gerenciamento de riscos. Utilizaremos a distância entre a previsão do modelo e 0,5 como a probabilidade de vitória. Quanto mais próximo o modelo estiver de 0,5, menor é a probabilidade de vitória, e menor deve ser o tamanho da aposta.

Veja como ficará a função online_trading modificada:

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    # Get the current account balance
    account_info = mt5.account_info()
    account_balance = account_info.balance

    # Set the initial volume for opening trades
    volume = 0.1

    # Set the initial peak balance
    peak_balance = account_balance

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        # Calculate the daily drop in account balance
        account_info = mt5.account_info()
        current_balance = account_info.balance
        daily_drop = (account_balance - current_balance) / account_balance

        # Calculate the probability of winning based on the distance between the model's prediction and 0.5
        probability_of_winning = abs(signal[-1] - 0.5) * 2

        # Calculate the optimal volume for opening trades using the Kelly criterion
        optimal_volume = (probability_of_winning - (1 - probability_of_winning) / risk_reward_ratio) / risk_reward_ratio * account_balance / price_ask

        # Reduce the volume for opening trades by 10% with a step of 0.01 lot for each day of daily drop
        if daily_drop > 0.02:
            optimal_volume -= 0.01
            optimal_volume = max(optimal_volume, 0.01)
        elif current_balance > peak_balance:
            optimal_volume = (probability_of_winning - (1 - probability_of_winning) / risk_reward_ratio) / risk_reward_ratio * account_balance / price_ask
            peak_balance = current_balance

        # Set the volume for opening trades
        volume = optimal_volume

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

Nesta função, adicionei as variáveis probability_of_winning e optimal_volume. probability_of_winning armazena a probabilidade de vitória, que calculo como a distância entre a previsão do modelo e 0,5, multiplicada por 2. optimal_volume contém o tamanho ideal da aposta, calculado com o critério de Kelly.

No bloco if daily_drop > 0.05:, reduzo optimal_volume em 10% com incremento de 0,01 lote. Também adicionei a condição elif current_balance > peak_balance:, que verifica se o saldo atual da conta ultrapassou o nível máximo anterior. Se sim, recalculo optimal_volume com base no saldo atual e na relação ganho/perda, atualizando peak_balance.

Este sistema de gerenciamento de volume baseado no critério de Kelly me permitirá otimizar automaticamente o tamanho da aposta, dependendo da probabilidade de vitória e da relação ganho/perda. Dessa forma, posso maximizar o lucro e minimizar o risco de rebaixamento.

Implementação de negociação multimoeda e cálculos paralelos

A negociação multimoeda permite ao algoritmo negociar várias paridades cambiais ao mesmo tempo, diversificando os riscos. Isso é implementado através de uma lista symbols com as paridades.

Os cálculos paralelos aceleram o processo, executando tarefas simultaneamente. Usamos a biblioteca threading — para cada paridade, é criado um thread separado com a função process_symbol.

A função process_symbol carrega os dados da paridade, os transforma, treina o modelo XGBoost, testa o modelo e, em seguida, realiza a negociação online, atualizando os dados periodicamente.

São criados threads para todas as paridades na lista symbols. Após o término de todos os threads, o programa aguarda sua conclusão usando thread.join().

Assim, foi implementado um sistema de negociação multimoeda de alta performance e multithreading baseado em XGBoost.

import threading

def process_symbol(symbol):
    try:
        # Retrieve data for the specified symbol
        raw_data = retrieve_data(symbol)
        if raw_data is None:
            print("Данные для символа {} не найдены".format(symbol))
            return None

        # Augment data
        augmented_data = augment_data(raw_data)

        # Markup data
        marked_data = markup_data(augmented_data.copy(), 'close', 'label')

        # Label data
        labeled_data = label_data(marked_data, symbol)

        # Generate new features
        labeled_data_generate = generate_new_features(labeled_data, num_features=100, random_seed=1)

        # Cluster features by GMM
        labeled_data_clustered = cluster_features_by_gmm(labeled_data_generate, n_components=4)

        # Feature engineering
        labeled_data_engineered = feature_engineering(labeled_data_clustered, n_features_to_select=10)

        # Train XGBoost classifier
        train_data = labeled_data_engineered[labeled_data_engineered.index <= FORWARD]
        test_data = labeled_data_engineered[labeled_data_engineered.index > FORWARD]
        xgb_clf = train_xgboost_classifier(train_data, num_boost_rounds=1000)

        # Test XGBoost classifier
        test_features = test_data.drop(['label', 'labels'], axis=1)
        test_labels = test_data['labels']
        initial_balance = 10000.0
        markup = 0.00001
        test_model(xgb_clf, test_features, test_labels, markup, initial_balance)

        # Online trading
        position_id = None
        while True:
            # Get the last 2000 data points for online trading
            features = raw_data[-6000:].drop(['label', 'labels'], axis=1).values.tolist()

            # Update features every 6 seconds
            time.sleep(6)
            new_data = retrieve_data(symbol)
            if new_data is not None:
                raw_data = pd.concat([raw_data, new_data])
                raw_data = raw_data.dropna()

            # Online trading
            position_id = online_trading(symbol, features, xgb_clf, position_id)

    except Exception as e:
        print("Ошибка при обработке символа {}: {}".format(symbol, e))
        return None

symbols = ["EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD"]

# Create a list of threads for each symbol
threads = []
for symbol in symbols:
    thread = threading.Thread(target=process_symbol, args=(symbol,))
    thread.start()
    threads.append(thread)

# Wait for all threads to complete
for thread in threads:
    thread.join()

Após executar o código, enfrentamos um problema de sobreposição de saídas na tela (prints) de diferentes threads. Isso torna a saída ilegível e dificulta a depuração e o monitoramento do desempenho do algoritmo. Apesar de várias tentativas para resolver esse problema, ainda não conseguimos evitar a sobreposição das saídas.

Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31




No data for symbol USDCAD yet (attempt 1)No data for symbol NZDUSD yet (attempt 1)No data for symbol AUDUSD yet (attempt 1)
No data for symbol GBPUSD yet (attempt 1)


Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31



No data for symbol USDCAD yet (attempt 2)No data for symbol AUDUSD yet (attempt 2)No data for symbol GBPUSD yet (attempt 2)


Instruments in terminal: 31Instruments in terminal: 31

Instruments in terminal: 31
No data for symbol GBPUSD yet (attempt 3)
Instruments in terminal: 31

Mesmo com essa dificuldade, o algoritmo funciona corretamente e realiza suas funções. Ele processa os dados com sucesso, treina o modelo e executa negociações para cada paridade cambial na lista symbols. Os cálculos paralelos aumentam consideravelmente a velocidade do algoritmo e melhoram sua eficiência.

Assim, vemos que o algoritmo executa corretamente as negociações:

Possíveis melhorias futuras do sistema

Aprendizado de máquina quântico

Atualmente, utilizamos modelos de aprendizado clássico, mas planejamos, no futuro, migrar para aprendizado de máquina quântico com o uso de qubits, o que aumentará a precisão e a velocidade. Apesar das dificuldades atuais com os computadores quânticos, softwares e algoritmos específicos já estão sendo desenvolvidos. Tenho planos de explorar e integrar aprendizado quântico em nossa plataforma, o que pode representar um avanço significativo.

Feedback do mercado: aprendizado por reforço

Para aprimorar o sistema de negociação, podemos implementar aprendizado por reforço. O sistema funcionará como um agente interagindo com o mercado, recebendo recompensas por operações lucrativas e punições por operações com prejuízo. Utilizando algoritmos como o DQN, a plataforma aprenderá e se adaptará, melhorando suas previsões.

Inteligência de enxame para otimização de stops e take profits

Podemos aplicar inteligência de enxame, usando o algoritmo Particle Swarm Optimization (PSO) para ajustar os parâmetros de stop loss e take profit de forma mais eficaz. O sistema gerará diversos parâmetros, avaliando sua eficiência com base em dados históricos. O PSO ajudará a encontrar parâmetros ideais, aumentando a adaptabilidade e reduzindo os riscos.

Considerações finais

Nosso modelo de aprendizado de máquina para negociação utiliza métodos de pré-processamento de dados, análise de dados e algoritmos como XGBoost. Implementamos técnicas como adição de ruído, deslocamento temporal, cálculo de características, balanceamento de classes e validação cruzada. A precisão é de cerca de 60% nos dados de teste.

Planejamos integrar cálculos quânticos, aprendizado por reforço e inteligência de enxame para a escolha de parâmetros de stop loss e take profit. Isso promete melhorar a qualidade do aprendizado, a eficiência com dados reais e o gerenciamento de riscos.

Mas há um desafio: com essas tecnologias, a competição entre algoritmos no mercado se intensificará. No passado, os traders competiam entre si, mas agora, o mais importante é qual algoritmo será superior.