Sviluppo di un robot di trading in Python (parte 3): Implementazione di un algoritmo di trading basato su un modello

Nel primo articolo della serie, abbiamo caricato il dataset, inserito le etichette, arricchito il dataset ed eseguito l'etichettatura del dataset. Il secondo articolo è stato dedicato alla creazione e all'addestramento del modello, nonché all'implementazione della convalida incrociata e del bagging. 

Ora che il nostro modello è stato addestrato e testato, è il momento di iniziare a fare trading reale utilizzando la libreria MetaTrader 5 per Python. Questa potente libreria ci permette di automatizzare il trading direttamente con Python utilizzando le funzioni e le classi fornite dalla piattaforma MetaTrader 5.

Implementazione di un algoritmo di trading basato su un modello

Per implementare un algoritmo di trading basato sul nostro modello, utilizzeremo il seguente approccio. L'algoritmo di base consiste nell'aprire operazioni con stop loss e take profit preimpostati che corrispondono alle etichette generate dal modello. Se il modello prevede un aumento del prezzo dell'asset, apriamo una posizione long con i livelli di stop loss e take profit impostati. Se il modello prevede un calo del prezzo dell'asset, apriamo una posizione short con parametri simili di stop loss e take profit.

La libreria MetaTrader 5 per Python fornisce gli strumenti necessari per gestire l'apertura e la chiusura delle operazioni, nonché l’impostazione dei livelli di stop loss e take profit. Questo ci permette di automatizzare completamente il trading basato sulle previsioni del modello.

Utilizzando i dati ottenuti nelle fasi precedenti di analisi e addestramento, possiamo trasmettere i segnali per aprire e chiudere le posizioni sulla piattaforma MetaTrader 5 in tempo reale, garantendo così la continuità e la precisione del nostro algoritmo di trading.

Pertanto, l'integrazione del nostro modello addestrato con la libreria MetaTrader 5 per Python ci consente di creare un algoritmo di trading efficiente e automatizzato che opera in base alle previsioni del modello, gestendo i rischi con stop loss preimpostati e proteggendo i profitti con take profit.

Impostazione dell'ambiente, del terminale di trading ed esecuzione dell'algoritmo

Per prima cosa, dobbiamo configurare l'ambiente e il terminale di trading MetaTrader 5. A tal fine, seguire i seguenti passaggi:

Installare le librerie Python con il comando pip:

pip install numpy pandas MetaTrader5 scikit-learn xgboost

Indicare il percorso del file eseguibile del terminale nei collegamenti al terminale:

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

Implementazione del trading online

Per implementare il trading online, aggiungeremo la funzione online_trading che aprirà le operazioni in base alle previsioni del nostro modello.

La funzione online_trading accetta i seguenti argomenti:

• symbol - simbolo negoziato
• features - elenco delle caratteristiche da utilizzare per effettuare le previsioni
• model - modello addestrato da utilizzare per fare previsioni

All'interno della funzione online_trading, per prima cosa ci colleghiamo al terminale MetaTrader 5 utilizzando il percorso specificato in terminal_path. Quindi otteniamo i prezzi correnti del simbolo utilizzando la funzione mt5.symbol_info_tick(symbol).

Successivamente, utilizziamo il nostro modello per prevedere il segnale in base alle caratteristiche passate. Se la previsione è positiva (superiore a 0,5), apriamo una posizione long, mentre se la previsione è negativa (inferiore a 0,5), apriamo una posizione short.

Impostiamo anche stop loss e take profit per ogni trade per minimizzare i rischi.

Se abbiamo già raggiunto il numero massimo di operazioni aperte (impostato nella costante MAX_OPEN_TRADES), non ne apriamo di nuove e attendiamo che una delle operazioni aperte venga chiusa.

Se le previsioni non ci permettono di aprire un nuovo trade, aspettiamo che appaia un nuovo segnale.

Al termine della funzione, viene restituito il risultato dell'esecuzione del trade se è stata piazzata con successo, oppure None se l'operazione non è stata piazzata.

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]

Avvio dell'algoritmo di trading online

Per avviare l'algoritmo di trading online, chiamiamo la funzione process_symbol, passandole il simbolo negoziato.

All'interno della funzione process_symbol, chiamiamo la funzione online_trading, passandole gli argomenti richiesti, e avviamo un ciclo che verrà eseguito finché non verrà interrotto.

Alla fine del ciclo, effettuiamo una pausa di 6 secondi per non sovraccaricare il terminale MetaTrader 5.

Se si verifica un errore durante l'esecuzione dell'algoritmo, stampare un messaggio di errore e interrompere l'esecuzione.

Sistema intelligente di gestione del rischio e del drawdown

La gestione del rischio è la pietra miliare di una strategia di trading di successo. Uno dei rischi principali che i trader devono affrontare è il rischio di drawdown, quando i prezzi dell’asset scendono al di sotto di un livello predeterminato. Per minimizzare questo rischio, è necessario un sistema di gestione del rischio efficace, che sia in grado di adattarsi alle mutevoli condizioni di mercato.

Svilupperemo un sistema che riduce automaticamente il volume delle operazioni quando il saldo del conto si riduce, utilizzando gli strumenti della libreria MetaTrader 5 per Python.

Le regole di base del sistema:

1. Recupero giornaliero dell’attuale saldo del conto - ogni giorno il sistema recupera l’attuale saldo del conto per analizzarne le variazioni.

2. Riduzione del volume delle operazioni durante un drawdown - se il saldo è sceso di oltre il 2% in un giorno, il sistema ridurrà automaticamente il volume delle operazioni aperte del 10%. Questo avviene con incrementi di 0,01 lotti per ridurre gradualmente i rischi.

3. Ulteriore riduzione del volume se il saldo continua a diminuire - se il saldo continua a diminuire, ogni giorno il volume delle transazioni verrà ridotto di un ulteriore 10% e di 0,01 lotti, garantendo un'ulteriore protezione del capitale.

4. Ritorno al volume originale dopo il ripristino del saldo - quando l’attuale saldo del conto supera il picco precedente, il sistema riporta automaticamente il volume di trading al valore originale. Questo aiuta a ripristinare la piena attività di trading dopo un calo temporaneo del volume dovuto a un drawdown.

Sono state aggiunte nuove variabili alla funzione online_trading: account_balance - per memorizzare il saldo corrente, peak_balance - per memorizzare il livello di saldo massimo precedente e daily_drop - per tracciare il drawdown giornaliero. Queste variabili sono utilizzate per implementare la logica di gestione del rischio.

Codice di esempio:

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)

Implementazione della gestione dei lotti basata sul criterio di Kelly

La gestione della dimensione del lotto è un altro aspetto importante della gestione del rischio nel trading. Uno dei metodi più diffusi per controllare la densità dei lotti è il criterio di Kelly. Il criterio di Kelly è un'equazione matematica che aiuta a determinare la dimensione ottimale della scommessa in base alla probabilità di vincita e al rapporto tra vincite e perdite.

In questa sede vedremo come implementare la gestione delle dimensioni del lotto di Kelly nel nostro sistema di gestione del rischio. Utilizzeremo la distanza tra la previsione del modello e 0,5 come probabilità di vincita. Quanto più la previsione del modello è vicina allo 0,5, tanto più bassa è la probabilità di vincita e tanto minore dovrebbe essere la dimensione della scommessa.

Ecco come appare la funzione online_trading modificata:

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)

In questa funzione ho aggiunto le variabili probability_of_winning e optimal_volume. probability_of_winning memorizza la probabilità di vincita calcolata come distanza tra la previsione del modello e 0,5 moltiplicata per 2. optimal_volume contiene la dimensione ottimale della scommessa calcolata con il criterio di Kelly.

Nel blocco 'if daily_drop > 0,05:', diminuisco il volume ottimale del 10% con incrementi di 0,01 lotti. Ho anche aggiunto la condizione "elif current_balance > peak_balance:", che controlla se il saldo attuale del conto ha superato il livello di picco precedente. In caso affermativo, ricalcolo optimal_volume per il saldo corrente e il rapporto vincite/perdite, mentre peak_balance viene aggiornato.

Questo sistema di gestione delle dimensioni del lotto di Kelly mi consentirà di ottimizzare automaticamente le dimensioni della mia scommessa in base alla probabilità di vincita e al rapporto vincita/perdita. In questo modo posso massimizzare i profitti e minimizzare il rischio di drawdown.

Implementazione di operazioni multivaluta e calcolo parallelo

L'operatività multivaluta consente all'algoritmo di negoziare diverse coppie di valute contemporaneamente, diversificando i rischi. È implementato tramite l'elenco 'symbols' con le coppie.

L'elaborazione in parallelo accelera il lavoro eseguendo i compiti simultaneamente. Utilizziamo la libreria 'threading' - per ogni coppia viene creato un thread separato con la funzione process_symbol.

process_symbol scarica i dati della coppia, li trasforma, addestra il modello XGBoost, lo testa e poi lo negozia online, aggiornando periodicamente i dati.

I threads vengono creati per tutte le coppie di "symbols". Dopo che tutti i thread sono stati completati, il programma li attende utilizzando thread.join().

È stato quindi implementato un sistema di trading multi-thread ad alte prestazioni e multivaluta basato su 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("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()

Dopo aver eseguito il codice, abbiamo riscontrato un problema di sovrapposizione dell'output dello schermo (stampe) da parte di thread differenti. Ciò rende illeggibile l'output sullo schermo e rende difficile il debug e il monitoraggio del funzionamento dell'algoritmo. Nonostante i numerosi tentativi di risolvere questo problema, non è stato ancora possibile evitare la sovrapposizione degli output.

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

Nonostante questo problema, l'algoritmo stesso funziona correttamente e svolge le sue funzioni. Gestisce con successo i dati, addestra il modello ed esegue il trading per ogni coppia di valute dell'elenco "symbols". Il calcolo parallelo consente di aumentare significativamente la velocità dell'algoritmo e di migliorarne l'efficienza.

Quindi, vediamo che l'algoritmo apre correttamente i trade:

Ulteriore possibilità di miglioramento del sistema

Apprendimento automatico quantistico

Attualmente utilizziamo l'addestramento classico dei modelli, ma in futuro prevediamo di passare all'apprendimento automatico quantistico utilizzando i qubit per migliorare l'accuratezza e la velocità. Nonostante le attuali difficoltà dei computer quantistici, si stanno già sviluppando software e algoritmi speciali. Ho intenzione di ricercare e implementare l'apprendimento quantistico nel nostro sistema, che potrebbe rappresentare una svolta significativa.

Feedback del mercato: apprendimento per rinforzo

Per migliorare il sistema di trading, possiamo implementare l'apprendimento per rinforzo. Il sistema agirà come un agente che interagisce con il mercato, ricevendo ricompense per le operazioni profittevoli e penalità per quelle non profittevoli. Utilizzando algoritmi come il DQN, il sistema imparerà e si adatterà, migliorando le sue previsioni.

Intelligenza a sciame per la selezione degli stop e dei take profit

Per migliorare l'efficienza del nostro sistema, possiamo applicare l'intelligenza a sciame utilizzando l'algoritmo Particle Swarm Optimization (PSO). Il sistema genererà diversi parametri di stop loss e take profit, valutandone l'efficienza sulla base dei dati storici. PSO ci aiuterà a selezionare i parametri ottimali, migliorando l'adattabilità e riducendo i rischi.

Conclusioni

Il nostro modello di apprendimento automatico per il trading utilizza la pre-elaborazione dei dati, l'analisi dei dati e gli algoritmi di tipo XGBoost. Applichiamo anche l'aggiunta di rumore, il time shifting, il calcolo delle caratteristiche, il bilanciamento delle classi e la convalida incrociata. L'accuratezza è di circa il 60% sui dati di prova.

In seguito verranno implementati il calcolo quantistico, l'apprendimento per rinforzo e l'intelligenza a sciame per la scelta degli stop loss e dei take profit. Questo migliorerà la qualità dell’addestramento, l'efficienza sui dati reali e la gestione del rischio.

Ma c'è una fregatura - queste tecnologie creeranno una feroce concorrenza tra gli algoritmi presenti sul mercato. Prima i trader erano in competizione tra loro, ora si tratta più che altro di stabilire quale sia l'algoritmo migliore.