Développer un robot de trading en Python (Partie 3) : Mise en œuvre d'un algorithme de trading basé sur un modèle

Dans le premier article de la série, nous avons chargé l'ensemble de données, placé les étiquettes, enrichi l'ensemble de données et effectué l'étiquetage de l'ensemble de données. Le deuxième article est consacré à la création et à l'entraînement du modèle, ainsi qu'à la mise en œuvre de la validation croisée et de la mise en sac (bagging). 

Maintenant que notre modèle est formé et testé, il est temps de commencer à trader en utilisant la bibliothèque MetaTrader 5 pour Python. Cette puissante bibliothèque nous permet d'automatiser le trading directement à travers Python en utilisant les fonctions et les classes fournies par la plateforme MetaTrader 5.

Mise en œuvre d'un algorithme de trading basé sur un modèle

Pour mettre en œuvre un algorithme de trading basé sur notre modèle, nous utiliserons l'approche suivante. L'algorithme de base consiste à ouvrir des transactions avec des stop loss prédéfinis et à prendre des bénéfices correspondant aux étiquettes générées par le modèle. Si le modèle prévoit une hausse du prix de l'actif, nous ouvrons une position longue avec des niveaux de stop loss et de take profit. Si le modèle prévoit une baisse du prix de l'actif, nous ouvrons une position courte avec des paramètres de stop loss et de take profit similaires.

La bibliothèque MetaTrader 5 pour Python fournit les outils nécessaires pour gérer l'ouverture et la clôture des transactions, ainsi que pour définir les niveaux de stop loss et de take profit. Cela nous permet d'automatiser entièrement le trading sur la base des prévisions du modèle.

En utilisant les données obtenues lors des étapes précédentes d'analyse et de formation, nous pouvons transmettre des signaux d'ouverture et de fermeture de positions sur la plateforme MetaTrader 5 en temps réel, assurant ainsi la continuité et la précision de notre algorithme de trading.

Ainsi, l'intégration de notre modèle entraîné à la bibliothèque MetaTrader 5 pour Python nous permet de créer un algorithme de trading efficace et automatisé qui effectue des transactions sur la base des prédictions du modèle, en gérant les risques avec des stop loss prédéfinis et en protégeant les profits avec des take profits.

Mise en place de l'environnement, du terminal de trading et exécution de l'algorithme

Tout d'abord, nous devons configurer l'environnement et le terminal de trading MetaTrader 5. Pour cela, suivez les étapes suivantes :

Installez les bibliothèques Python à l'aide de la commande pip :

pip install numpy pandas MetaTrader5 scikit-learn xgboost

Indiquez le chemin d'accès au fichier exécutable du terminal dans les liens vers le terminal :

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

Mise en œuvre du trading en ligne

Pour mettre en œuvre le trading en ligne, nous ajouterons la fonction online_trading qui ouvrira des transactions en fonction des prévisions de notre modèle.

La fonction online_trading prend les arguments suivants :

• symbol - symbole négocié
• features - liste des caractéristiques à utiliser pour établir des prévisions
• model - modèle formé à utiliser pour faire des prévisions

Dans la fonction online_trading, nous nous connectons d'abord au terminal MetaTrader 5 en utilisant le chemin spécifié dans terminal_path. Ensuite, nous obtenons les prix actuels du symbole à l'aide de la fonction mt5.symbol_info_tick(symbol).

Puis nous utilisons notre modèle pour prédire le signal sur la base des caractéristiques passées. Si la prévision est positive (> 0,5), nous ouvrons une position longue, et si la prévision est négative (< de 0,5), nous ouvrons une position courte.

Nous fixons également un stop loss et un take profit pour chaque transaction afin de minimiser les risques.

Si nous avons déjà atteint le nombre maximum de transactions ouvertes (défini dans la constante MAX_OPEN_TRADES), nous n'en ouvrons pas de nouvelles et attendons que l'une des transactions ouvertes soit clôturée.

Si les prévisions ne nous permettent pas d'ouvrir une nouvelle transaction, nous attendons également qu'un nouveau signal apparaisse.

À la fin de la fonction, nous renvoyons le résultat de l'exécution de la transaction si elle a été placée avec succès, ou None si aucune transaction n'a été placée.

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("No data found for symbol {}".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]

Lancement de l’algorithme de trading en ligne

Pour lancer l'algorithme de trading en ligne, nous appelons la fonction process_symbol, en lui transmettant le symbole négocié.

Dans la fonction process_symbol, nous appelons la fonction online_trading, en lui transmettant les arguments nécessaires, et nous lançons une boucle qui fonctionnera jusqu'à ce qu'elle soit interrompue.

A la fin de la boucle, nous faisons une pause de 6 secondes afin de ne pas surcharger le terminal MetaTrader 5.

Si une erreur survient pendant l'exécution de l'algorithme, un message d'erreur est écrit dans le journal et l'exécution est interrompue.

Système intelligent de gestion des risques et des prélèvements

La gestion du risque est la pierre angulaire d'une stratégie de trading réussie. L'un des principaux risques auxquels les traders sont confrontés est le risque de réduction (drawdown), lorsque les prix des actifs tombent en dessous d'un niveau prédéterminé. Pour minimiser ce risque, il faut un système de gestion des risques efficace, capable de s'adapter à l'évolution des conditions du marché.

Nous allons développer un système qui réduit automatiquement le volume des transactions lorsque le solde du compte diminue, en utilisant les outils de la bibliothèque MetaTrader 5 pour Python.

Les règles de base du système :

1. Récupération quotidienne du solde du compte courant - chaque jour, le système récupère le solde du compte courant afin d'analyser les changements.

2. Réduction du volume des transactions lors d'une baisse - si le solde a baissé de plus de 2% en une journée, le système réduira automatiquement le volume des transactions ouvertes de 10%. Cette opération s'effectue par tranches de 0,01 lot afin de réduire progressivement les risques.

3. Réduction supplémentaire du volume si le solde continue de baisser - si le solde continue de baisser, le volume des transactions sera réduit chaque jour de 10% supplémentaires et de 0,01 lot, ce qui garantit une protection supplémentaire du capital.

4. Retour au volume initial après rétablissement du solde - lorsque le solde actuel du compte dépasse le pic précédent, le système ramène automatiquement le volume d'échange à sa valeur initiale. Cela permet de rétablir une activité de trading complète après une baisse temporaire du volume due à une réduction.

De nouvelles variables ont été ajoutées à la fonction online_trading : account_balance - pour stocker le solde actuel, peak_balance - pour stocker le niveau de solde maximal précédent et daily_drop - pour suivre le drawdown quotidien. Ces variables sont utilisées pour mettre en œuvre la logique de gestion des risques.

Exemple de code :

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)

Mise en œuvre de la gestion des lots sur la base du critère de Kelly

La gestion de la taille des lots est un autre aspect important de la gestion des risques dans le trading. L'une des méthodes les plus répandues pour contrôler la densité des lots est le critère de Kelly. Le critère de Kelly est une équation mathématique qui permet de déterminer la taille optimale d'une mise en fonction de la probabilité de gain et du rapport entre les gains et les pertes.

Nous verrons ici comment intégrer la gestion de la taille des lots Kelly dans notre système de gestion des risques. Nous utiliserons la distance entre la prédiction du modèle et 0,5 comme probabilité de victoire. Plus la prédiction du modèle est proche de 0,5, plus la probabilité de gagner est faible et plus la taille de la mise doit être réduite.

Voici à quoi ressemble la fonction online_trading modifiée :

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)

Dans cette fonction, j'ai ajouté les variables probability_of_winning et optimal_volume. probability_of_winning stocke la probabilité de gain calculée comme une distance entre la prévision du modèle et 0,5 multipliée par 2. optimal_volume contient la taille optimale de la mise calculée à l'aide du critère de Kelly.

Dans le bloc 'if daily_drop > 0.05:', je diminue optimal_volume de 10% par incréments de 0.01 lot. J'ai également ajouté la condition "elif current_balance > peak_balance :", qui vérifie si le solde actuel du compte a dépassé le niveau maximal précédent. Si c'est le cas, je recalcule le volume optimal pour le solde actuel et le ratio gains/pertes, et le solde maximal est mis à jour.

Ce système de gestion des lots Kelly me permettra d'optimiser automatiquement la taille de ma mise en fonction de la probabilité de gain et du ratio gains/pertes. De cette façon, je peux maximiser les profits et minimiser le risque de baisse.

Mise en œuvre d'opérations multidevises et de calculs parallèles

Le fonctionnement multidevises permet à l'algorithme de trader plusieurs paires de devises à la fois, ce qui permet de diversifier les risques. Elle est mise en œuvre via la liste "symbols" avec des paires.

L'informatique parallèle accélère le travail en exécutant des tâches simultanément. Nous utilisons la bibliothèque "threading" - un thread distinct est créé pour chaque paire à l'aide de la fonction process_symbol.

process_symbol télécharge les données de la paire, les transforme, entraîne le modèle XGBoost, le teste, puis le négocie en ligne, en mettant à jour les données périodiquement.

Des threads sont créés pour toutes les paires de "symboles". Lorsque tous les threads sont terminés, le programme les attend en utilisant thread.join().

Ainsi, un système de trading multidevise multithread haute performance basé sur XGBoost est mis en œuvre.

import threading

def process_symbol(symbol):
    try:
        # Retrieve data for the specified symbol
        raw_data = retrieve_data(symbol)
        if raw_data is None:
            print("No data found for symbol {}".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("Error processing {} symbol: {}".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()

Après avoir exécuté le code, nous avons rencontré un problème de chevauchement des sorties d'écran (impressions) des différents threads. Cela rend la sortie à l'écran illisible et complique le débogage et le contrôle du fonctionnement de l'algorithme. Malgré de nombreuses tentatives pour résoudre ce problème, il n'a pas encore été possible d'éviter le chevauchement des sorties.

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

Malgré ce problème, l'algorithme lui-même fonctionne correctement et remplit ses fonctions. Il traite avec succès les données, entraîne le modèle et effectue des transactions pour chaque paire de devises de la liste des "symboles". Le calcul parallèle permet d'augmenter considérablement la vitesse de l'algorithme et d'améliorer son efficacité.

Nous constatons donc que l'algorithme ouvre correctement les transactions :

Amélioration potentielle du système

Apprentissage machine quantique

Nous utilisons actuellement un modèle d'apprentissage classique, mais nous prévoyons à l'avenir de passer à l'apprentissage automatique quantique en utilisant des qubits pour améliorer la précision et la vitesse. Malgré les difficultés actuelles liées aux ordinateurs quantiques, des logiciels et des algorithmes spéciaux sont déjà en cours de développement. J'ai l'intention de faire des recherches et de mettre en œuvre l'apprentissage quantique dans notre système, ce qui pourrait constituer une avancée significative.

Retour d'information sur le marché : apprentissage par renforcement

Pour améliorer le système de trading, nous pouvons mettre en œuvre l'apprentissage par renforcement. Le système agira comme un agent interagissant avec le marché, recevant des récompenses pour les transactions rentables et des pénalités pour celles qui ne le sont pas. Grâce à des algorithmes, tels que le DQN, le système apprendra et s'adaptera, améliorant ainsi ses prévisions.

L'intelligence en essaim pour la sélection des arrêts et des prises de profit

Pour améliorer l'efficacité de notre système, nous pouvons appliquer l'intelligence en essaim à l'aide de l'algorithme d'optimisation de l'essaim de particules (PSO). Le système génère différents paramètres de stop loss et de take profit, en évaluant leur efficacité sur la base de données historiques. PSO nous aidera à sélectionner les paramètres optimaux, améliorant ainsi l'adaptabilité et réduisant les risques.

Conclusion

Notre modèle d'apprentissage automatique de la trading utilise des algorithmes de prétraitement et d'analyse des données ainsi que des algorithmes de type XGBoost. Nous appliquons également l'ajout de bruit, le décalage temporel, le calcul des caractéristiques, l'équilibrage des classes et la validation croisée. La précision est d'environ 60% sur les données de test.

L'informatique quantique, l'apprentissage par renforcement, ainsi que l'intelligence en essaim pour le choix des stop loss et des take profit seront mis en œuvre ultérieurement. Cela améliorera la qualité de la formation, l'efficacité sur la base de données réelles et la gestion des risques.

Mais il y a un hic : ces technologies vont créer une concurrence féroce entre les algorithmes sur le marché. Auparavant, les traders étaient en concurrence les uns avec les autres ; aujourd'hui, il s'agit plutôt de savoir quel algorithme est le meilleur.