Разработка торгового робота на Python (Часть 3): Реализация торгового алгоритма на основе модели

В первой статье цикла мы загружали датасет, расставляли метки, обогащали датасет, а также проводили марикровку датасета. Вторая статья цикла была посвящена созданию, обучению модели, внедрению кросс-валидации и бэггинга. 

Теперь, когда наша модель обучена и проверена, настало время приступить к реальному трейдингу с использованием библиотеки MetaTrader 5 для Python. Эта мощная библиотека позволяет нам автоматизировать торговлю напрямую через Python, используя функции и классы, предоставляемые платформой MetaTrader 5.

Реализация торгового алгоритма на основе модели

Для реализации торгового алгоритма на основе нашей модели, мы будем использовать следующий подход. Основной алгоритм заключается в том, чтобы открывать сделки с заранее заданными стоп-лоссами и тейк-профитами, которые соответствуют меткам, сгенерированным моделью. Если модель предсказывает, что цена актива повысится, мы открываем лонг-позицию с установленными уровнями стоп-лосса и тейк-профита. Если модель предсказывает понижение цены, мы открываем шорт-позицию с аналогичными параметрами стоп-лосса и тейк-профита.

Библиотека MetaTrader 5 для Python обеспечивает необходимые инструменты для управления открытием и закрытием сделок, а также для установки уровней стоп-лосса и тейк-профита. Это позволяет нам полностью автоматизировать процесс торговли на основе прогнозов нашей модели.

Используя данные, полученные на предыдущих этапах анализа и обучения, мы можем в реальном времени передавать сигналы на открытие и закрытие позиций на платформе MetaTrader 5, обеспечивая тем самым непрерывность и точность нашего торгового алгоритма.

Таким образом, интеграция нашей обученной модели с библиотекой MetaTrader 5 для Python позволяет нам создать эффективный и автоматизированный торговый алгоритм, который осуществляет торговлю на основе прогнозов модели, управляя рисками с помощью заданных стоп-лоссов и защищая прибыли с помощью тейк-профитов.

Настройка окружения, торгового терминала и запуск алгоритма

Для начала необходимо настроить окружение и торговый терминал MetaTrader 5. Для этого выполните следующие шаги:

Установите библиотеки для Python, используя команду pip:

pip install numpy pandas MetaTrader5 scikit-learn xgboost

В ссылках на терминал укажем наш путь к исполняемому файлу терминала:

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

Пишем онлайн-торговлю

Для реализации онлайн-торговли мы напишем функцию online_trading , которая будет открывать сделки в соответствии с прогнозом нашей модели.

Функция online_trading принимает следующие аргументы:

• symbol - символ инструмента, по которому будет вестись торговля
• features - список признаков, которые будут использоваться для прогнозирования
• model - обученная модель, которая будет использоваться для прогнозирования

Внутри функции online_trading мы сначала подключаемся к терминалу MetaTrader 5, используя путь, указанный в terminal_path . Затем мы получаем текущие цены на инструмент, используя функцию mt5.symbol_info_tick(symbol) .

Далее мы используем нашу модель для прогнозирования сигнала на основе переданных признаков. Если прогноз положительный (больше 0.5), мы открываем длинную позицию, а если прогноз отрицательный (меньше 0.5), мы открываем короткую позицию.

Мы также устанавливаем стоп-лосс и тейк-профит для каждой сделки, чтобы минимизировать риски.

Если мы уже достигли максимального количества открытых сделок (установлено в константе MAX_OPEN_TRADES ), мы не открываем новые сделки и ждем, пока одна из открытых сделок не будет закрыта.

Если прогноз не позволяет открыть новую сделку, мы также ждем, пока не появится новый сигнал.

В конце функции мы возвращаем результат выполнения сделки, если она была успешно открыта, или None , если сделка не была открыта.

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]

Запуск алгоритма онлайн-торговли

Для запуска алгоритма онлайн-торговли мы вызываем функцию process_symbol , передавая ей символ инструмента, по которому будет вестись торговля.

Внутри функции process_symbol мы вызываем функцию online_trading , передавая ей необходимые аргументы, и запускаем цикл, который будет выполняться, пока не будет прерван.

В конце цикла мы делаем паузу в 6 секунд, чтобы не перегружать терминал MetaTrader 5.

Если во время выполнения алгоритма возникла ошибка, мы выводим сообщение об ошибке и прерываем выполнение.

Интеллектуальная система управления рисками и просадкой

Управление рисками является краеугольным камнем успешной торговой стратегии. Один из основных рисков, с которым сталкиваются трейдеры, это риск просадки, когда цены активов падают ниже заранее определенного уровня. Для минимизации этого риска необходима эффективная система управления рисками, способная адаптироваться к изменениям рыночных условий.

Мы разработаем систему, автоматически снижающую объем сделок при просадке баланса счета, используя инструменты библиотеки MetaTrader 5 для Python.

Основные правила системы таковы:

1. Ежедневное получение текущего баланса счета: каждый день система будет получать текущий баланс счета для анализа изменений.

2. Уменьшение объема сделок при просадке: если баланс упал более чем на 2% за день, система автоматически уменьшит объем открываемых сделок на 10%. Это происходит с шагом 0.01 лота, чтобы постепенно снижать риски.

3. Дополнительное снижение объема при продолжающемся падении баланса: если просадка баланса продолжается, то каждый день объем сделок будет уменьшаться дополнительно на 10% и на 0.01 лота, обеспечивая дальнейшую защиту капитала.

4. Возврат к исходному объему после восстановления баланса: когда текущий баланс счета превысит предыдущий пик, система автоматически вернет объем сделок к исходному значению. Это помогает восстановить полную торговую активность после временного снижения объема из-за просадки.

В функции online_trading добавлены новые переменные: account_balance - для хранения текущего баланса, peak_balance - для хранения предыдущего пикового уровня баланса и daily_drop - для отслеживания суточной просадки. Эти переменные используются для реализации логики управления рисками.

Пример кода:

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)

Внедрение управлением лотностью по критерию Келли

Управление лотностью - это еще один важный аспект управления рисками в торговле. Одним из популярных методов управления лотностью является критерий Келли. Критерий Келли - это математическая формула, которая помогает определить оптимальный размер ставки, основываясь на вероятности выигрыша и отношении выигрыша к проигрышу.

В этой статье мы рассмотрим, как внедрить управление лотностью по критерию Келли в нашу систему управления рисками. Мы будем использовать расстояние между прогнозом модели и 0.5 в качестве вероятности выигрыша. Чем ближе прогноз модели к 0.5, тем меньше вероятность выигрыша, и тем меньше должен быть размер ставки.

Вот как будет выглядеть измененная функция online_trading :

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)

В этой функции я добавил переменные probability_of_winning и optimal_volume. probability_of_winning хранит вероятность выигрыша, которую я рассчитываю как расстояние между прогнозом модели и 0.5, умноженное на 2. А optimal_volume содержит оптимальный размер ставки, рассчитанный по критерию Келли.

В блоке if daily_drop > 0.05: я уменьшаю optimal_volume на 10% с шагом 0.01 лота. Также добавил условие elif current_balance > peak_balance:, которое проверяет, превысил ли текущий баланс счета предыдущий пиковый уровень. Если да, то я пересчитываю optimal_volume по текущему балансу и отношению выигрыш/проигрыш, а peak_balance обновляется.

Эта система управления лотностью по Келли позволит мне автоматически оптимизировать размер ставки в зависимости от вероятности выигрыша и отношения выигрыш/проигрыш. Так я смогу максимизировать прибыль и минимизировать риск просадки.

Внедрение мультивалютной работы и параллельных вычислений

Мультивалютная работа позволяет алгоритму торговать сразу несколькими валютными парами, диверсифицируя риски. Реализована через список symbols с парами.

Параллельные вычисления ускоряют работу, выполняя задачи одновременно. Используется библиотека threading - для каждой пары создается отдельный поток с функцией process_symbol.

process_symbol загружает данные пары, преобразует их, обучает XGBoost модель, тестирует ее и затем ведет онлайн-торговлю, периодически обновляя данные.

Создаются потоки для всех пар из symbols. После завершения всех потоков, программа ожидает их с помощью thread.join().

Таким образом реализована высокопроизводительная многопоточная мультивалютная торговая система на базе 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()

После запуска кода, мы столкнулись с проблемой наложения вывода на экран (принтов) из разных потоков. Это делает вывод на экран нечитаемым и затрудняет отладку и мониторинг работы алгоритма. Несмотря на многочисленные попытки решить эту проблему, пока что никак не удается избежать наложения вывода.

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

Несмотря на эту проблему, сам алгоритм работает корректно и выполняет свои функции. Он успешно обрабатывает данные, обучает модель и выполняет торговлю для каждой валютной пары из списка symbols. Параллельные вычисления позволяют значительно увеличить скорость работы алгоритма и улучшить его эффективность.

Итак, видим что алгоритим верно открывает сделки:

Потенциальное дальнейшее улучшение системы

Квантовое машинное обучениe

Сейчас мы используем классическое обучение моделей, но в будущем планируем перейти на квантовое машинное обучение с использованием кубитов для повышения точности и скорости. Несмотря на текущие сложности с квантовыми компьютерами, специальные ПО и алгоритмы уже разрабатываются. Я планирую исследовать и внедрять квантовое обучение в нашу систему, что может стать значительным прорывом.

Обратная связь от рынка: обучение с подкреплением

Чтобы усовершенствовать торговую систему, мы можем внедрить обучение с подкреплением. Система будет работать как агент, взаимодействующий с рынком, получая вознаграждения за прибыльные сделки и наказания за убыточные. Используя алгоритмы, такие как DQN, система будет учиться и адаптироваться, улучшая прогнозы.

Роевой интеллект для подбора стопов и тейков

Для повышения эффективности нашей системы можно применить роевой интеллект, используя алгоритм Particle Swarm Optimization (PSO). Система будет генерировать различные параметры стопов и тейков, оценивая их эффективность на исторических данных. PSO поможет подобрать оптимальные параметры, улучшая адаптивность и снижая риски.

Заключение

Наша модель машинного обучения для торговли использует методы предобработки данных, анализа данных и алгоритмы типа XGBoost. Применяются добавление шума, сдвиг во времени, расчет признаков, балансировка классов, кросс-валидация. Точность около 60% на тестовых данных.

Планируется внедрить квантовые вычисления, обучение с подкреплением, роевой интеллект для выбора стопов и тейков. Это позволит улучшить качество обучения, эффективность на реальных данных и управление рисками.

Но есть одна загвоздка - из-за этих технологий на рынке появится жесткая конкуренция между алгоритмами. Раньше трейдеры соревновались друг с другом, а теперь главное - чей алгоритм круче.