Commercio quantitativo - pagina 33
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Strategia di trading di deep learning dall'inizio alla produzione utilizzando TensorFlow 2.0 e TFX
Strategia di trading di deep learning dall'inizio alla produzione utilizzando TensorFlow 2.0 e TFX
Sono lieto di presentarmi come Denis e ti do un caloroso benvenuto su ClosetoAlgotrading, il tuo canale di riferimento per tutto ciò che riguarda il trading algoritmico.
È passato un po' di tempo da quando l'idea mi è venuta in mente per la prima volta: creare una strategia di trading utilizzando esclusivamente il potere del deep learning. Il concetto ruota attorno allo sviluppo di una rete neurale in grado di identificare autonomamente i parametri necessari per eseguire operazioni redditizie. Per intraprendere questo entusiasmante viaggio, ho deciso di condurre un esperimento dal vivo, che spero possa catturare anche il vostro interesse. Nei prossimi episodi, ti guiderò attraverso ogni passaggio coinvolto nell'implementazione di un approccio di data science alla creazione di una solida strategia di trading, dalle fasi iniziali alla produzione finale.
Il mio obiettivo è coprire tutte le fasi intermedie in modo completo, inclusa la preparazione dei dati, test rigorosi e oltre. Guardando al futuro, utilizzerò TensorFlow 2.0 ed esplorerò le possibilità offerte dalla pipeline tfx. Intendo evitare calcoli o regole complesse, affidandomi invece al potere del deep learning per accertare se possiamo creare un'impresa veramente redditizia. Se questa idea risuona con te, ti incoraggio a iscriverti al canale e unirti a me in questa avvincente spedizione. Insieme, esploreremo i meandri del trading algoritmico e ci sforzeremo di sbloccarne il potenziale nascosto.
Per coloro che sono curiosi di approfondire l'approccio della scienza dei dati, una semplice ricerca su Google produrrà varie risorse che chiariscono l'argomento. Tra i risultati, potresti imbatterti in articoli informativi e rappresentazioni visive che delineano i passaggi necessari per seguire questa metodologia.
Il primo tassello cruciale del nostro percorso è la fase di comprensione del business. In questo frangente, dobbiamo definire meticolosamente i nostri obiettivi e stabilire indicatori chiave di prestazione (KPI) che fungano da valori misurabili per valutare l'efficacia della nostra strategia nel raggiungimento di questi obiettivi. Per intraprendere questa fase, è fondamentale dedicare del tempo per comprendere a fondo le complessità del tuo specifico dominio aziendale. Acquisendo una profonda comprensione del tuo obiettivo, puoi procedere con chiarezza e concentrazione. È imperativo discernere se miri a prevedere risultati specifici o classificare fenomeni particolari.
Per determinare la natura del nostro compito, dobbiamo cercare risposte a domande fondamentali. Se la nostra indagine ruota attorno a "Quanto" o "Quanti", abbiamo a che fare con un compito di regressione. D'altra parte, se indaghiamo su "quale categoria", ci avventuriamo nel regno della classificazione, e così via. Una volta compreso il tipo di attività che cerchiamo di realizzare, è essenziale definire le metriche che indicheranno il successo. Nel nostro caso, queste metriche potrebbero includere il ritorno sull'investimento (ROI) e l'accuratezza. Dopotutto, il nostro obiettivo finale è ottenere profitti dal mercato, il che richiede una solida comprensione dei futuri movimenti dei prezzi.
Prevedere efficacemente il futuro movimento dei prezzi implica non solo determinarne la direzione, ma anche identificare il preciso livello di prezzo e il momento in cui verrà raggiunto. Tuttavia, la semplice conoscenza della direzione non è sufficiente. Richiediamo l'esatto livello di prezzo e il momento in cui verrà raggiunto. Per evitare interminabili periodi di attesa per il nostro prezzo obiettivo, possiamo definire un obiettivo di prezzo minimo previsto e un periodo di attesa massimo. In altre parole, cerchiamo di accertare la direzione dei futuri movimenti dei prezzi, simile a un compito di classificazione in cui il prezzo può salire, scendere o rimanere allo stesso livello.
Per misurare inizialmente le prestazioni del nostro modello nella previsione della direzione, possiamo utilizzare l'accuratezza della classificazione. Questa metrica quantifica il numero di previsioni corrette diviso per il numero totale di previsioni, moltiplicato per 100 per esprimerlo in percentuale. Ora, per quanto riguarda il nostro livello di prezzo obiettivo? Per la nostra strategia di trading, possiamo definire il livello di profitto come percentuale del nostro capitale investito. Inoltre, dobbiamo determinare la nostra tolleranza al rischio stabilendo un livello di stop loss come rischio massimo accettabile per una singola operazione. I nostri livelli di profitto e stop servono come valori di ROI per ogni operazione. Ad esempio, supponiamo di acquistare azioni a $ 100 e di venderle quando raggiungono $ 105. Questo movimento di prezzo del 5% produrrebbe un ritorno del 5% sul nostro investimento. Con i nostri livelli di uscita definiti, che comprendono sia take profit che stop-loss, dobbiamo affrontare la questione del tempo. Non desideriamo aspettare indefinitamente che il prezzo raggiunga i livelli desiderati.
Pertanto, stabiliamo un periodo di detenzione massimo, anche se utilizzando il volume scambiato invece di un intervallo di tempo fisso. La logica alla base di questa scelta diventerà più chiara nel prossimo episodio, dove approfondirò la preparazione dei dati.
Per riassumere il nostro approccio fino ad ora: stiamo sviluppando una strategia intraday che impiega take profit, stop loss e un periodo di detenzione massimo per chiudere le posizioni. Per avviare le negoziazioni, addestreremo un modello di classificazione in grado di prevedere la direzione futura del prezzo: su, giù o piatto. Inizialmente, utilizzeremo l'accuratezza come misura dell'efficacia del nostro modello. Con questa base in atto, concludiamo la nostra discussione per oggi. Abbiamo definito i nostri obiettivi, traguardi e metriche di rendimento. Nella puntata successiva, approfondiremo i nostri dati, preparando set di dati ed etichette per ulteriori analisi e sviluppi.
Non perdere la prossima puntata del nostro viaggio. Fino ad allora, abbi cura di te e attendo con impazienza il nostro prossimo incontro.
Strategia di Deep Learning Trading dall'inizio alla produzione. Seconda parte.
Strategia di Deep Learning Trading dall'inizio alla produzione. Seconda parte.
Sono lieto di darvi il benvenuto nella seconda parte del nostro avvincente viaggio nella creazione di un sistema di trading. Nel video precedente, abbiamo discusso i nostri obiettivi e oggi ci concentreremo sulla preparazione e l'etichettatura del nostro set di dati. Quindi tuffiamoci dentro!
Per iniziare, ho definito un insieme di funzioni che ci aiuteranno nella preparazione del set di dati. Innanzitutto, dobbiamo caricare i nostri dati. Per la dimostrazione di oggi, userò un piccolo set di dati per mantenere gestibile il tempo di esecuzione del codice. Come puoi vedere, il set di dati comprende i dati del tick, incluse informazioni come ora, prezzo, volume, offerta e domanda. Ai fini di questa dimostrazione, utilizzerò i dati di un periodo di un anno. Iniziamo esaminando alcune statistiche per comprendere le caratteristiche del set di dati. Uno degli aspetti chiave che osserviamo è il prezzo minimo e massimo, che si aggirano intorno ai $100. Questo è vantaggioso in quanto consente un facile calcolo delle percentuali di profitto.
Inoltre, ho introdotto un parametro cruciale nel set di dati: la dimensione dello spread. Lo spread è calcolato come differenza tra i prezzi Ask e Bid. Perché è importante la dimensione dello spread? Per illustrare, consideriamo un esempio in cui il prezzo Bid è $ 100 e il prezzo Ask è $ 101. In questo caso, lo spread è pari a $1. Se dovessimo acquistare e vendere immediatamente il titolo, perderemmo sempre lo spread che, in questo esempio, ammonta a $1. Per ottenere informazioni sulla dimensione dello spread, ho calcolato lo spread medio su tutti i giorni per ogni secondo. Come illustrato nel grafico, lo spread varia tipicamente tra 1 e 2 centesimi, con occorrenze occasionali di spread leggermente maggiori. Sulla base di questa analisi, possiamo decidere di eseguire operazioni solo se lo spread è inferiore a 3 centesimi.
È interessante notare che il grafico mostra che gli spread maggiori tendono a verificarsi nei primi minuti dopo l'apertura del mercato. Di conseguenza, è prudente saltare i primi 10-15 minuti quando si implementa una strategia intraday. Ora che abbiamo definito il periodo di tempo ed esaminato lo spread, possiamo procedere a generare etichette per il nostro modello, che prevederanno la direzione del movimento del prezzo. Come generiamo queste etichette? Come accennato nel video precedente, poiché non abbiamo trigger per l'apertura di una posizione, dobbiamo generare etichette per ogni barra in base al rendimento previsto.
Per fare ciò, utilizzeremo il metodo della finestra, in cui le etichette vengono generate quando i prezzi superano le barriere della finestra. Ecco come funziona: definiamo una finestra di lunghezza n barre e impostiamo le barriere della finestra superiore e inferiore in base al nostro rendimento atteso in percentuale. Mentre facciamo scorrere questa finestra su tutte le barre, con un passo di una barra, se il prezzo esce dalla finestra, la prima barra nella finestra riceverà l'etichetta. Prima di procedere con la generazione dell'etichetta, stabiliamo i parametri per la finestra. Sebbene l'idea alla base sia semplice, la selezione della dimensione ottimale della finestra e dei livelli di barriera può essere impegnativa. Personalmente, ho trascorso molto tempo alle prese con questo problema e devo ancora trovare una soluzione definitiva.
Per affrontare questa sfida, calcolerò la volatilità storica nel corso della giornata e l'intero set di dati. Ad esempio, il grafico presentato illustra la variazione di prezzo su ogni tick in un giorno, insieme alla corrispondente volatilità. Inoltre, possiamo valutare la volatilità nell'intero set di dati. Come mostrato, la volatilità media è di appena lo 0,003%, che equivale a circa 30 centesimi del prezzo corrente. Tuttavia, non intendo utilizzare una finestra che copra l'intera giornata. Per determinare la lunghezza della finestra, ho tentato di generare 100 finestre con dimensioni casuali e ho valutato la volatilità media all'interno di ciascuna finestra. Il grafico risultante mostra la volatilità media per finestre di diverse lunghezze. Selezionando una dimensione della finestra di 50 barre, ad esempio, possiamo prevedere una volatilità di circa lo 0,001%.
Questo valore di volatilità diventa utile per definire il nostro rendimento minimo atteso e calcolare la dimensione del nostro prezzo stop-loss. Con queste informazioni in mano, possiamo procedere a generare barre del volume dai nostri dati tick. L'utilizzo delle barre invece delle zecche ci consente di calcolare più facilmente la lunghezza della finestra, poiché una barra contiene tipicamente un volume simile, garantendo condizioni stabili. Per generare una barra del volume, iteriamo attraverso i tick e accumuliamo il volume finché non supera o eguaglia un volume target predefinito (ad esempio, 1000). I tick incontrati durante questa fase di accumulo rappresentano una barra del volume. Generiamo ad esempio le barre del volume per un singolo giorno. Come illustrato, otteniamo 179 barre per il giorno selezionato.
Di conseguenza, il grafico dei prezzi ora è costituito da queste barre del volume. Inoltre, possiamo calcolare la variazione percentuale in ogni barra e la volatilità giornaliera utilizzando il prezzo di chiusura. Tuttavia, non intendo utilizzare una finestra che copre l'intera giornata. Per determinare la lunghezza della finestra, ho utilizzato la volatilità media e le finestre generate casualmente per l'intero set di dati. Il grafico risultante mostra la volatilità della finestra sull'intero set di dati.
Ora che abbiamo completato questi passaggi preparatori, siamo pronti per generare le etichette. Per questa dimostrazione ho scelto una dimensione della finestra di 50 barre e un rendimento atteso dello 0,003%, che corrisponde a circa 30 centesimi in base al prezzo medio. Al termine del processo di etichettatura, potremmo trovare diverse etichette simili, note come etichette incrociate. Per evitare di avere etichette identiche per eventi diversi, manterremo solo le etichette con la distanza minima tra la prima barra della finestra e la barra in cui il prezzo attraversa la barriera della finestra. Al momento dell'ispezione, osserviamo che abbiamo circa 700 etichette, distribuite uniformemente tra le tre categorie (su, giù e piatte).
Ora salviamo il nostro set di dati. Creeremo due file: uno contenente il set di dati della barra del volume e un altro file contenente le informazioni sui tick per ciascuna barra. Quest'ultimo può rivelarsi utile nel nostro modello, quindi vale la pena conservarlo. Con questo, interrompo la nostra discussione per oggi. Credo che abbiamo coperto un ampio terreno e per coloro che sono interessati ad approfondire l'etichettatura dei dati, consiglio di esplorare i capitoli 3 e 4 del libro di Marcos Lopez de Prado, che forniscono preziose informazioni.
Il nostro prossimo passo riguarderà l'ingegnerizzazione delle funzionalità e l'esecuzione di tutto attraverso la pipeline tfx. Spero di creare presto un nuovo episodio per condividere informazioni più intriganti.
Fino ad allora, abbi cura di te e non vedo l'ora di vedere il nostro prossimo video.
Strategia di Deep Learning Trading dall'inizio alla produzione. Parte III. Pipeline TFX.
Strategia di Deep Learning Trading dall'inizio alla produzione. Parte III. Pipeline TFX.
Sono entusiasta di darti il bentornato a un altro episodio di "Close to AlgoTrading" con me, Denis. Abbiamo ripreso il nostro esperimento dopo le vacanze di Capodanno e, sebbene i progressi siano stati lenti, stiamo ancora andando avanti. Nel video di oggi, daremo un'occhiata più da vicino ai nostri dati etichettati ed esploreremo la pipeline TFX. Quindi, tuffiamoci subito!
Nel video precedente, abbiamo creato correttamente le etichette per i nostri dati, ma ho dimenticato di mostrarti come appaiono su un grafico. Come rapido aggiornamento, abbiamo archiviato tutti i dati in un nuovo frame di dati. Andiamo avanti e leggiamo questo frame di dati.
All'interno del nostro data frame, la colonna 'dir' contiene le etichette, mentre la colonna 'cross_idx' rappresenta il numero di tick quando il prezzo attraversa la nostra finestra definita. Per rappresentare visivamente gli eventi di posizione aperta e chiusa basati su queste colonne, ho creato una semplice funzione. Sul grafico, un evento di posizione aperta è indicato da un triangolo pieno, mentre un evento di posizione chiusa è rappresentato da un triangolo vuoto.
Come puoi vedere, la maggior parte degli eventi aperti si verificano nei punti massimi o minimi locali nel grafico dei prezzi. Andando avanti, continueremo a lavorare con un piccolo set di dati, simile a quello che abbiamo utilizzato in precedenza. Inoltre, suddividerò il set di dati in set di dati di addestramento, valutazione e test.
Ora che abbiamo una migliore comprensione delle nostre etichette, passiamo al passaggio successivo e iniziamo a lavorare con la pipeline TFX. Per chi non ha familiarità con TFX, è l'acronimo di Tensorflow Extended ed è un potente framework progettato specificamente per attività di machine learning scalabili e ad alte prestazioni. La pipeline TFX è costituita da una sequenza di componenti che eseguono varie fasi del flusso di lavoro di machine learning, come l'inserimento dei dati, la modellazione, l'addestramento, l'inferenza del servizio e la gestione della distribuzione.
Per familiarizzare con TFX, consiglio di esplorare la pagina Web ufficiale di Tensorflow TFX, che fornisce informazioni dettagliate sui suoi componenti e su come sono interconnessi. Puoi trovare i link pertinenti nella descrizione del video.
Dato che sono anche nuovo su TFX, impareremo insieme in ogni episodio. Oggi ci concentreremo sui primi quattro componenti della pipeline. Presentiamoli brevemente:
ExampleGen: questo componente di input iniziale della pipeline acquisisce il set di dati di input e, facoltativamente, lo suddivide in diversi sottoinsiemi. Nel nostro caso, non supporta direttamente le suddivisioni di serie temporali personalizzate, quindi ho suddiviso manualmente i dati in set di dati di addestramento, valutazione e test.
StatisticsGen: questo componente calcola le statistiche per il set di dati, fornendo informazioni sulla distribuzione dei dati, la deviazione standard, i valori mancanti e altro ancora. Genera artefatti statistici per ulteriori analisi.
SchemaGen: dopo aver esaminato le statistiche, il componente SchemaGen crea uno schema di dati basato sulle caratteristiche dei dati osservate. Lo schema descrive la struttura e le proprietà dei nostri dati.
ExampleValidator: questo componente verifica la presenza di anomalie e valori mancanti nel set di dati, utilizzando le statistiche e lo schema come riferimenti. Aiuta a identificare eventuali modelli di dati imprevisti o incoerenti.
Per assicurarci di essere sulla strada giusta, utilizzerò l'esempio del taxi di Chicago fornito dal team di Tensorflow come modello. Questo esempio illustra il flusso di lavoro end-to-end, inclusa l'analisi dei dati, la convalida, la trasformazione, l'addestramento del modello e la pubblicazione.
Ora, riportiamo la nostra attenzione sui nostri dati. Dopo aver importato i moduli richiesti e impostato le variabili necessarie per le cartelle di dati di input e output, possiamo tentare di caricare i nostri dati nella pipeline TFX. La cartella di input contiene le sottocartelle per i set di dati di valutazione, addestramento e test.
Utilizzando il componente ExampleGen, dovremmo essere in grado di caricare facilmente i nostri dati nella pipeline. Tuttavia, sembra che ExampleGen non supporti direttamente le divisioni di serie temporali personalizzate. Per impostazione predefinita, suddivide i dati solo in set di addestramento e di valutazione. Fortunatamente, possiamo suddividere manualmente i dati e configurare la nostra configurazione di suddivisione dell'input, garantendo una mappatura uno a uno tra le suddivisioni di input e output.
Di conseguenza, il componente ExampleGen produce due artefatti: uno per il set di dati di addestramento e un altro per il set di dati di valutazione. Esaminiamo i primi tre elementi del nostro set di addestramento per verificare che corrisponda al nostro set di dati originale. Andando avanti, passiamo l'output dal componente ExampleGen al componente StatisticsGen. Questo componente genera artefatti statistici sia per i set di dati di addestramento che per quelli di valutazione. Con un solo comando, possiamo rappresentare visivamente le statistiche del set di dati, inclusa la distribuzione dei dati, la deviazione standard, i valori mancanti e altro ancora.
Qui possiamo osservare le statistiche per il set di dati di addestramento, ottenendo preziose informazioni sulle caratteristiche dei dati. Possiamo anche esaminare lo stesso insieme di statistiche per l'insieme di valutazione. Sulla base delle statistiche, notiamo che solo il 2% delle nostre etichette è diverso da zero, suggerendo che i nostri eventi di ingresso per operazioni redditizie potrebbero essere valori anomali. Ciò potrebbe rappresentare una sfida in futuro a causa dello squilibrio tra le classi.
Successivamente, generiamo automaticamente lo schema dei dati utilizzando il componente SchemaGen. Questo schema è derivato dalle statistiche osservate, ma potremmo anche definire la nostra descrizione dei dati se lo desideriamo. L'output è uno schema che fornisce una descrizione completa della struttura e delle proprietà dei nostri dati. Infine, raggiungiamo il componente ExampleValidator, che convalida i dati in base alle statistiche e allo schema generati. Controlla eventuali anomalie o incongruenze nel set di dati. Ad esempio, nell'esempio del taxi di Chicago, la caratteristica '_company' aveva un valore di stringa imprevisto. Possiamo utilizzare ExampleValidator per rilevare tali problemi nel nostro set di dati.
Nel nostro caso, fortunatamente, non riscontriamo anomalie o incoerenze nel nostro set di dati. Questo è un segnale positivo, che indica che i nostri dati sono relativamente puliti e in linea con le nostre aspettative. Bene, questo conclude la nostra rapida introduzione a TFX. Nel prossimo episodio, approfondiremo i restanti componenti TFX ed esploreremo come trasformare i nostri dati e addestrare il nostro modello.
Grazie per aver guardato e non vedo l'ora di vederti nel prossimo video!
Parte IV. Strategia di Deep Learning Trading dall'inizio alla produzione. Conduttura TFX 2.
Parte IV. Strategia di Deep Learning Trading dall'inizio alla produzione. Conduttura TFX 2.
Benvenuti in un altro episodio di "Close to Algotrading". Sono Denis e oggi continueremo ad esplorare la pipeline TFX come parte della costruzione della nostra strategia di trading.
Nel video precedente, abbiamo coperto i primi quattro componenti della pipeline TFX: ExampleGen, StatisticsGen, SchemaGen e ExampleValidator. Questi componenti hanno gettato le basi per la nostra pipeline, garantendo la convalida e la coerenza dei dati.
Ora, tuffiamoci nei componenti rimanenti: Transformer, Trainer, Evaluator, ModelValidator e Pusher. Questi componenti ci consentiranno di trasformare i nostri dati, addestrare il nostro modello, valutarne le prestazioni, convalidare il modello rispetto a una linea di base e, infine, spingere il modello convalidato in un ambiente di produzione.
Ma prima di procedere, permettetemi di affrontare alcuni punti importanti. Sebbene la pipeline TFX offra un framework potente, vale la pena notare che potrebbe avere ancora alcuni bug e alcuni componenti potrebbero essere in costruzione. Tuttavia, affrontiamo attentamente ogni passaggio e discutiamo di eventuali limitazioni lungo il percorso. Nel video precedente, abbiamo convalidato con successo i nostri dati e ora è il momento di passare alla fase di trasformazione. A tale scopo, utilizzeremo il componente Transformer fornito da TFX.
Il componente Transform è responsabile dell'esecuzione delle trasformazioni dei dati e dell'ingegnerizzazione delle funzionalità coerenti sia per l'addestramento che per l'offerta. Ciò significa che possiamo utilizzare la stessa funzione di trasformazione dei dati sia per addestrare il modello sia per utilizzarlo in produzione. Questa funzionalità è uno dei motivi principali per cui ho iniziato a esplorare TFX in primo luogo.
Per iniziare il processo di trasformazione, dobbiamo creare un paio di file Python. Il primo file conterrà le nostre costanti, come un elenco di caratteristiche numeriche ed etichette. Il secondo file conterrà una funzione di preelaborazione (preprocessing_fn), che è una funzione di callback utilizzata da tf.Transform per preelaborare i dati di input. In questa funzione, definiremo le fasi di trasformazione dei dati e costruzione delle funzionalità. Per ora, concentriamoci sulla trasformazione di tutte le funzionalità di input numerico in punteggi z e sulla modifica dei valori dell'etichetta rispettivamente da -1, 0 e 1 a 0, 1 e 2. Questa trasformazione dell'etichetta è necessaria perché lo stimatore TensorFlow prevede valori positivi.
È importante notare che nella versione corrente di TFX sono supportati solo gli stimatori TensorFlow. Se preferisci utilizzare un modello Keras, devi convertirlo in uno stimatore utilizzando l'API model_to_estimator. Sebbene la versione 0.21 di TFX affermi di supportare i modelli Keras per il componente Trainer, ho riscontrato alcuni problemi con la sua funzionalità di contesto interattivo. Si spera che il team TFX affronti presto questi problemi e fornisca uno strumento stabile e perfettamente funzionante.
Ora, procediamo con la trasformazione dei dati. Come puoi vedere, il componente Transform prevede i seguenti parametri come input: gli esempi generati, lo schema dei dati e il percorso del file contenente la funzione preprocessing_fn. Al termine della trasformazione, possiamo passare alla creazione e all'addestramento del nostro modello. Il componente Trainer sarà responsabile dell'addestramento del modello in base alle specifiche che definiamo.
Nel file Python contenente il nostro modello e le funzioni di input, definiamo una funzione trainer_fn che verrà chiamata dal componente Trainer. Questa funzione dovrebbe restituire un dizionario con i seguenti elementi:
All'interno di questo file, definiamo la funzione _input_fn, che genera le caratteristiche e le etichette di input sia per l'addestramento che per la valutazione. Abbiamo anche funzioni aggiuntive, come _example_serving_receiver_fn, che costruisce gli input di servizio, e _eval_input_receiver_fn, che prepara gli input necessari per TensorFlow Model Analysis (TFMA).
Per creare il nostro stimatore, definiamo una funzione build_estimator. In questa funzione, impostiamo il set di funzionalità di input e creiamo il nostro stimatore. Vale la pena ricordare che ho utilizzato DNNLinearCombinedEstimator perché DNNClassifier e DNNEstimator stavano causando errori relativi al passaggio di funzionalità da TensorFlow 1. Credo che non sia così poiché stiamo utilizzando i metodi TensorFlow 2. Purtroppo non ho trovato una soluzione a questo problema. Tuttavia, lo stimatore lineare sembra funzionare bene.
Ora che il nostro modello è definito, possiamo procedere con il training utilizzando il componente Trainer. Come puoi vedere, il componente Trainer si aspetta un module_file che contiene la funzione trainer_fn, insieme ad altri parametri come transformer_examples, data schema, transform graph e argomenti di addestramento e valutazione. Per ora, abbiamo specificato solo il numero di passaggi per la formazione e la valutazione. Dopo aver completato l'addestramento del modello, possiamo passare all'analisi del modello utilizzando TensorFlow Model Analysis (TFMA). Prima di procedere, assicurati di aver installato TFMA seguendo il link fornito. TFMA ci consente di eseguire analisi sul nostro modello, sull'intero set di dati o su sezioni di caratteristiche specifiche. In questo caso, eseguiremo l'analisi su tre sezioni: il set di dati completo, l'etichetta e due funzionalità specifiche.
Analizzando il set di dati completo, osserviamo una notevole precisione del 98 percento. Tuttavia, quando si esaminano le prestazioni del modello in base alle etichette, notiamo che prevede costantemente l'etichetta 0. Questo risultato era previsto a causa delle etichette non bilanciate e dell'assenza di funzioni utili nel nostro modello. Tuttavia, TFMA fornisce un modo conveniente per valutare le prestazioni del modello.
Andando avanti, abbiamo il componente ModelValidator, che ci aiuta a convalidare i nostri modelli esportati. Confronta i nuovi modelli rispetto a una linea di base (come il modello attualmente disponibile) e determina se soddisfano i criteri predefiniti. Questa convalida include la valutazione dei modelli su un set di dati di valutazione e il calcolo di metriche come AUC e perdita. Se le metriche del nuovo modello soddisfano i criteri specificati dallo sviluppatore relativi alla linea di base, il modello viene considerato "abbastanza buono" e contrassegnato come tale.
Infine, abbiamo il componente Pusher, che verifica se il modello ha superato la validazione. Se il modello soddisfa i criteri di convalida, viene inviato a una destinazione file specificata. Questo passaggio assicura che solo i modelli convalidati vengano distribuiti nell'ambiente di produzione.
Per concludere la nostra pipeline, possiamo esportare tutti i componenti in una pipeline Apache Beam. Possiamo quindi impacchettare tutti i file necessari in un archivio zip. Decomprimendo i file dall'archivio nella nostra directory di lavoro sul server, possiamo eseguire la pipeline. Una volta completata l'esecuzione, avremo un modello addestrato pronto per l'uso con TensorFlow Serving. Se sei interessato a imparare come avviare e utilizzare TensorFlow Serving da un container Docker, puoi trovare un tutorial video sul mio canale.
Sebbene abbiamo coperto molto terreno in questa serie, è importante notare che l'attuale versione di TFX ha ancora alcune limitazioni. A seconda dei requisiti specifici, potrebbe essere necessario implementare una pipeline che si basa esclusivamente sulla funzione di trasformazione con un modello Keras. Tuttavia, spero che questa esplorazione di TFX sia stata istruttiva e utile.
Nel prossimo video, torneremo al nostro obiettivo principale di sviluppare una strategia di trading. Resta sintonizzato per quello! Non dimenticare di commentare, iscriverti e mettere mi piace a questo video. Grazie per aver guardato e ci vediamo al prossimo!
Parte V GIGO. Strategia di Deep Learning Trading dall'inizio alla produzione.
Parte V GIGO. Strategia di Deep Learning Trading dall'inizio alla produzione.
Bentornati a un altro episodio di "Close to Algotrading". Mi chiamo Denis e sono qui per condividere le mie esperienze e i miei fallimenti nello sviluppo di un sistema di trading basato sul deep learning.
Ho dedicato molto tempo all'implementazione dell'intero sistema utilizzando TensorFlow, ma devo ammettere che sono piuttosto deluso dalla qualità della libreria. Sebbene apprezzi il concetto, la documentazione fornita da TensorFlow è stata fonte di frustrazione. Sembra che anche le menti brillanti con i loro dottorati di ricerca facciano fatica a scrivere una documentazione ben strutturata. Sebbene sia migliorato rispetto al passato, rimane confuso in diversi punti.
Tuttavia, la documentazione è solo un problema minore rispetto al problema più grande che ho riscontrato. Molte funzioni semplicemente non funzionano come previsto quando ho provato a usarle, e anche gli esempi ufficiali a volte non funzionano correttamente. Questo mi ha fatto dubitare che potessi aver perso alcuni punti fondamentali di questo framework. Ma torniamo all'argomento principale di questo video: i miei fallimenti. Come forse ricorderai, ho deciso di generare etichette per il movimento dei prezzi in base a una percentuale specificata. La maggior parte di queste etichette si è rivelata essere minimi o massimi locali nei dati.
Dopo aver eseguito una semplice elaborazione e preparazione dei dati, ho creato una semplice rete LSTM e l'ho messa alla prova. Le mie aspettative non erano eccezionalmente alte, ma i risultati sono stati davvero deludenti. Come puoi vedere nell'immagine di accompagnamento, la rete non è riuscita a imparare nulla di significativo.
Ora, è importante ricordare che una rete neurale non è pensata per fare miracoli. Forse è il momento di rivalutare il nostro approccio. Gli eventi che stiamo cercando di prevedere rappresentano solo il 2% dell'intero set di dati. Questi eventi possono essere considerati valori anomali e la nostra semplice rete fa fatica a distinguerli dal resto dei dati. Inoltre, c'è un'alta probabilità che questi eventi non siano correlati e abbiano cause distinte, rendendo difficile costruire un modello che li preveda con precisione.
Date queste sfide, è diventato evidente che dobbiamo concentrarci sulla migliore comprensione dei dati e sull'identificazione delle caratteristiche con potere predittivo. Con questo in mente, ho deciso di rivisitare una semplice strategia di media mobile. Nel nostro approccio iniziale, non avevamo una chiara comprensione del motivo per cui avremmo dovuto aprire una posizione. Tuttavia, ora abbiamo una strategia per aprire posizioni. Sebbene non sia perfetto, è una strategia ampiamente utilizzata che possiamo sfruttare. Ho aggiunto due medie mobili e un indicatore RSI (Relative Strength Index) al nostro set di dati e ho raccolto tutti gli eventi in cui le medie mobili si sono incrociate. Questo ci ha permesso di stimare le direzioni del movimento dei prezzi.
Successivamente, ho creato meta-etichette utilizzando lo stesso metodo di etichettatura di prima, ma questa volta ho etichettato solo le barre in cui le medie mobili si incrociavano. C'è una differenza importante qui: poiché conosciamo già la direzione della posizione (lunga o corta), il significato delle nostre etichette sarà diverso. Un'etichetta di 1 indica un profitto, -1 rappresenta una perdita e 255 è assegnato per altri casi. Con il set di dati e le etichette aggiornati, ho addestrato un semplice modello LSTM e ottenuto una curva ROC (Receiver Operating Characteristic) perfetta. La curva ROC mostra le prestazioni di un modello di classificazione a diverse soglie di classificazione. Il valore AUC (Area Under the Curve) della curva ROC ci aiuta a valutare quanto bene il modello distingue tra le classi.
Tuttavia, esaminando le previsioni del modello, ho notato che prevedeva costantemente la classe 0. Questo risultato si è verificato perché, ancora una volta, ho utilizzato l'intero set di dati anziché solo gli eventi rilevanti. Il nostro set di dati è rimasto sbilanciato e le funzionalità mancavano di capacità predittive. Le curve ROC non sono ideali per set di dati sbilanciati, in quanto possono mascherare le scarse prestazioni del modello nella previsione di altre classi.
Per affrontare lo squilibrio nei dati, ho apportato modifiche e mi sono concentrato solo sui dati relativi agli eventi aperti. Sfortunatamente, anche dopo queste modifiche, il mio modello non ha mostrato potere predittivo. Ha prodotto gli stessi risultati di un modello casuale. Ho anche tentato un semplice modello feedforward, che ha mostrato risultati leggermente migliori ma ancora insoddisfacenti. In conclusione, come puoi vedere, non c'è magia nel deep learning se alimenti il tuo modello con dati di scarsa qualità. Il principio di "immondizia dentro, immondizia fuori" vale in questo contesto. Inoltre, quando si ha a che fare con insiemi di dati altamente squilibrati e privi di funzionalità con un forte potere predittivo, un modello di classificazione tenderà a prevedere la classe che costituisce la maggior parte dell'insieme di dati.
Come accennato in precedenza, è fondamentale per noi comprendere i nostri dati e identificare i processi che possono aiutarci a trovare un modo per battere il mercato.
Questo conclude l'episodio di oggi. Spero che tu l'abbia trovato perspicace e informativo. Abbi cura di te, resta a casa e resta in salute.
Parte VI. Insegnamento rafforzativo. Strategia di Deep Learning Trading dall'inizio alla produzione
Parte VI. Insegnamento rafforzativo. Strategia di Deep Learning Trading dall'inizio alla produzione
Sono Denis e benvenuto a un altro episodio di "Close to Alga Trading". Nei nostri episodi precedenti, abbiamo lavorato per costruire una strategia di trading redditizia utilizzando il deep learning. Ricapitoliamo i nostri progressi finora.
Abbiamo iniziato osservando le condizioni di mercato alla ricerca di inefficienze. Una volta identificati, abbiamo creato semplici regole e preparato i dati per i nostri modelli di deep learning. Tuttavia, implementando il nostro approccio diretto, abbiamo scoperto che non produceva i risultati desiderati. Questo ci ha portato a renderci conto che dobbiamo ripensare il nostro approccio e prendere in considerazione strategie alternative.
Nell'episodio di oggi esploreremo una nuova direzione: l'apprendimento per rinforzo. L'apprendimento per rinforzo ha ottenuto un successo significativo in vari domini, superando le prestazioni umane in giochi come scacchi, Dota e Go. Viene anche utilizzato nella robotica di controllo e nelle auto a guida autonoma. Quindi, perché non applicarlo al trading? Anche se non posso garantirne il successo, è una strada intrigante da esplorare.
Per iniziare, approfondiamo una breve introduzione all'apprendimento per rinforzo e familiarizziamo con le definizioni chiave.
L'apprendimento per rinforzo può essere descritto come l'apprendimento attraverso prove ed errori per risolvere problemi di controllo ottimale. In termini più semplici, si tratta di trovare l'azione migliore da intraprendere in un dato stato dell'ambiente per massimizzare una ricompensa numerica finale. Per comprendere meglio questo concetto, visualizziamolo con una semplice analogia.
Immagina un trader seduto davanti a un monitor, che compra e vende azioni. Qui, il trader rappresenta l'agente, mentre il prezzo del grafico e il broker formano l'ambiente. L'agente osserva lo stato attuale dell'ambiente e intraprende azioni, come l'acquisto di azioni. In cambio, l'agente riceve una ricompensa, che potrebbe essere la commissione del broker. Man mano che l'ambiente cambia, l'agente può acquistare più azioni, vendere o non fare nulla. Alla fine della giornata di negoziazione, l'agente riceve un premio finale, che può essere positivo o negativo. L'obiettivo dell'agente è massimizzare questa ricompensa finale.
Nell'apprendimento per rinforzo, il nostro obiettivo è progettare agenti in grado di apprendere interagendo con un ambiente. Ora, familiarizziamo con le definizioni principali che incontreremo durante il nostro viaggio.
Agente: l'algoritmo che prende decisioni, esegue azioni, osserva l'ambiente, riceve feedback e mira a massimizzare la ricompensa.
Ambiente: il mondo in cui risiede l'agente. Comprende tutti i dati disponibili per il nostro agente per prendere decisioni.
Stato: la configurazione dell'ambiente rilevata dall'agente.
Ricompensa: il feedback che l'agente riceve dopo aver eseguito un'azione. È un valore che l'agente cerca di massimizzare. È importante sottolineare che, nell'apprendimento per rinforzo, la ricompensa non significa necessariamente denaro o un trofeo fisico. È semplicemente un valore numerico che può anche essere negativo e il nostro obiettivo è massimizzare questo valore.
Azione: tutto ciò che l'agente è in grado di eseguire in un dato ambiente. Per semplicità, consideriamo tre azioni: comprare, vendere o non fare nulla.
Episodio: un'esecuzione completa dell'intera attività.
Queste sono le definizioni principali che useremo durante il nostro viaggio. Ci sono altri termini importanti che tratteremo nei video futuri.
Con questa introduzione all'apprendimento per rinforzo, procederemo a conoscere l'ambiente e a creare il nostro ambiente utilizzando TensorFlow nel prossimo video.
Grazie per esserti unito a me oggi e non vedo l'ora di esplorare ulteriormente l'apprendimento per rinforzo con te. Arrivederci!
Parte VII. Insegnamento rafforzativo. Ambiente commerciale.
Parte VII. Insegnamento rafforzativo. Ambiente commerciale.
Sono Denis e stai guardando "Close to AlgoTrading". Nel nostro ultimo episodio, abbiamo fornito una breve introduzione all'apprendimento per rinforzo. Oggi ci immergeremo nella creazione di un ambiente di trading semplice per il nostro agente. Esploriamo i dettagli.
Innanzitutto, dobbiamo considerare cosa rappresenta l'ambiente di trading. Si basa esclusivamente sui dati sui prezzi o dovremmo incorporare fattori aggiuntivi come il portafoglio ordini completo, le notizie o persino le voci di Twitter? Questa decisione modellerà la complessità del nostro ambiente.
Successivamente, dobbiamo determinare le azioni che il nostro agente può eseguire. Dovrebbe essere limitato alle azioni di "acquisto" e "vendita" o può anche saltare alcuni passaggi? Definire lo spazio d'azione è fondamentale per il processo decisionale del nostro agente.
Ora, discutiamo l'obiettivo e come definiremo i premi. Nel mondo reale, l'ambiente di trading ha uno spazio di stato continuo. Tuttavia, per semplicità, manteniamo l'ambiente il più semplice possibile, consentendoci di comprenderne il funzionamento interno e l'implementazione.
Per iniziare, invece di utilizzare i dati sui prezzi reali, genereremo un processo di passeggiata casuale composto da soli 20 valori. Questi prezzi giornalieri simulati serviranno come input. L'episodio inizierà dalla metà di questa sequenza di prezzi, il che significa che lo stato iniziale includerà i 10 prezzi storici. I restanti prezzi invisibili saranno riempiti con zeri. Ad ogni passaggio, verrà aggiunto un nuovo prezzo all'array. L'episodio si concluderà quando tutti i 20 prezzi saranno visibili all'agente. Pertanto, abbiamo un totale di 10 passaggi fino al completamento dell'episodio.
Oltre ai dati sui prezzi, lo stato includerà informazioni sulla nostra posizione aperta. Rappresentiamo la posizione utilizzando la codifica one-hot: [0,0] per nessuna posizione aperta, [1,0] per una posizione lunga e [0,1] per una posizione corta.
Considerando le tipiche azioni di trading, includeremo "compra" e "vendi" per i casi in cui nessuna posizione è aperta. Tuttavia, se c'è già una posizione aperta, l'agente può solo scegliere di saltare o chiudere la posizione. Pertanto, in questo scenario, l'azione "vendi" o "acquista" equivale a "salta".
L'obiettivo del nostro agente è massimizzare i profitti e le perdite (PnL) nel periodo di 10 giorni. Pertanto, definiremo la ricompensa come il PnL giornaliero.
Con una chiara comprensione della struttura e del comportamento del nostro ambiente, possiamo ora procedere alla fase di implementazione. Come accennato in precedenza, utilizzeremo il framework TensorFlow (tf-agent). Il team di tf-agent ha fornito una guida completa sullo sviluppo di un ambiente adatto per tf-agent, che consiglio di consultare per una comprensione più approfondita del codice.
Per creare il nostro ambiente, inizieremo ereditando la classe PyEnvironment, in quanto definisce l'interfaccia che tutti gli ambienti Python devono implementare. All'interno della funzione Init, inizializzeremo le variabili, imposteremo gli stati iniziali e, soprattutto, specificheremo le specifiche di azione e osservazione. Nel nostro caso, lo spazio azione sarà composto da quattro diverse azioni, con valori minimo e massimo impostati rispettivamente su 0 e 3. La specifica dell'osservazione descriverà lo stato dell'ambiente, con il prezzo che parte da 0 e nessun limite massimo. Il tipo di dati per i prezzi sarà float. Restituire le specifiche di azione e osservazione è fondamentale per una perfetta integrazione con tf-agent.
La prossima funzione significativa da implementare è resettata. Questa funzione reimposterà l'ambiente al suo stato iniziale. Garantire la corretta attuazione di questa funzione è vitale per il corretto funzionamento dell'ambiente.
Ora, discutiamo la funzione più critica: passo. La funzione step riceve un'azione come parametro di input ed è responsabile della gestione delle transizioni di stato dell'ambiente. In questa funzione, gestiremo tutte le azioni possibili e calcoleremo il PnL (ricompensa). La funzione restituisce un time_step, che consiste nell'osservazione (la parte dello stato dell'ambiente che l'agente può osservare per scegliere le sue azioni nel passaggio successivo), la ricompensa (l'obiettivo di apprendimento dell'agente), step_type (che indica se questo time step è il primo, intermedio o ultimo in una sequenza) e sconto.
Nella funzione step, abbiamo due diversi scenari di ritorno: uno per i passaggi intermedi e un altro per l'ultimo passaggio dell'episodio.
Dopo aver creato l'ambiente, è essenziale validarlo per identificare e correggere eventuali bug. Il pacchetto util fornisce una funzione chiamata validate_py_environment, che può essere utilizzata per questo scopo. Inoltre, il controllo delle specifiche dell'ambiente contribuirà a garantire che tutto funzioni come previsto.
Con il nostro ambiente pronto per l'uso, è una buona idea testarlo con diverse azioni per eseguire il debug e convalidarne il comportamento.
Ho condotto alcuni test utilizzando un semplice DQN tf-agent, ed ecco i risultati. Dopo 20.000 passaggi, l'agente ha dimostrato prestazioni accettabili. Tuttavia, tieni presente che avevamo solo una serie temporale da far apprendere all'agente, rendendola relativamente semplice. Se introduciamo una seconda serie temporale ed eseguiamo 20.000 passaggi, i risultati potrebbero non essere così promettenti. Ma con circa 100.000 passaggi, le prestazioni dell'agente sono migliorate in modo significativo.
Parte VIII. Strategia di trading per l'apprendimento del rinforzo. DQN: QNetwork, QRNNNetwork
Parte VIII. Strategia di trading per l'apprendimento del rinforzo. DQN: QNetwork, QRNNNetwork
Ciao, mi chiamo Denis e stai guardando "Close to AlgoTrading". In questo video, forniremo un breve aggiornamento sul nostro ambiente precedente per l'agente di apprendimento per rinforzo. Forniremo anche una breve descrizione di Q-Learning e dell'agente DQN. Procederemo quindi a implementare i principali passaggi di apprendimento per un agente rDQN dalla libreria tf-agents e discuteremo i risultati del test.
Per iniziare, rivisitiamo l'ambiente di trading che abbiamo creato nel video precedente. In quell'ambiente, abbiamo utilizzato dati generati sintetici. Tuttavia, in questa versione aggiornata, il nostro ambiente riceverà un dataframe con dati storici come parametri di input. L'observation_spec per l'ambiente è un dizionario con due chiavi: "Price" e "Pos." La chiave "Prezzo" contiene 20 elementi con dati di apertura, chiusura, massimo, minimo e volume. Il tasto "Pos" contiene informazioni sulla nostra posizione aperta.
All'inizio di ogni episodio, selezioniamo casualmente una fetta di 20 prezzi dai nostri dati. Questa modifica consente al nostro agente di apprendimento per rinforzo di apprendere dai dati storici reali.
Andando avanti, discutiamo del Q-Learning e del concetto di Q-Table. Il Q-Learning implica l'assegnazione di un valore Q a ogni coppia di (stato, azione). Questa tabella, nota come Q-Table, viene utilizzata dall'agente per selezionare le azioni con il valore Q massimo nello stato corrente. L'agente esplora l'ambiente, riceve ricompense e aggiorna i valori Q in base alle ricompense osservate.
Per aggiornare i valori Q, utilizziamo una formula che coinvolge il vecchio valore Q e il futuro valore Q. Calcoliamo il valore Q futuro cercando il valore Q massimo per lo stato successivo nella nostra tabella Q. Con il valore Q futuro ottenuto, aggiorniamo il valore Q associato alla coppia di partenza (stato, azione).
Tuttavia, nel nostro caso, il mercato finanziario ha uno spazio di stato molto ampio, rendendo poco pratico l'utilizzo di una Q-Table. Per superare questa sfida, possiamo utilizzare una rete neurale profonda per prevedere i valori Q per un dato stato. Questo approccio, noto come agente DQN (agente Deep Q-Network), utilizza una rete Q, in cui i valori Q vengono aggiornati riducendo al minimo la perdita attraverso la retropropagazione. La funzione di perdita utilizzata nell'agente DQN è data da un'equazione specifica.
Ora che abbiamo una buona conoscenza del Q-Learning e dell'agente DQN, procediamo con l'implementazione dei principali passaggi di apprendimento per l'agente rDQN utilizzando la libreria tf-agents.
L'algoritmo di addestramento generale segue questi passaggi:
Creare l'ambiente è un compito semplice. Avvolgiamo il nostro ambiente di trading nel TFPyEnvironment, che consente una perfetta integrazione con gli agenti tf.
Successivamente, creiamo una Q-Network per l'agente DQN. La libreria tf-agents fornisce una classe Q-Network che possiamo usare per definire la nostra Q-network. Definiamo una semplice rete Q con uno strato nascosto completamente connesso composto da 40 neuroni. Poiché la nostra osservazione è un dizionario, definiamo anche un semplice livello di pre-elaborazione per essa.
Con la Q-Network creata, procediamo alla creazione di un agente DQN. Istanziamo la classe tf_agents.agents.dqn.dqn_agent, passando la nostra Q-network come parametro. Definiamo anche l'ottimizzatore e la funzione di perdita per addestrare il modello.
Per addestrare l'agente, abbiamo bisogno di dati dall'ambiente. Raccogliamo questi dati utilizzando una politica e, per questo passaggio, possiamo selezionare le azioni in modo casuale. L'agente DQN ha due policy: agent.policy, utilizzato per la valutazione e la distribuzione, e agent.collect_policy, utilizzato per la raccolta dei dati.
La raccolta dei dati comporta l'acquisizione dello stato corrente, la selezione di un'azione, la ricezione dello stato e della ricompensa successivi e l'archiviazione di queste informazioni in un buffer. Raccogliamo più passaggi o episodi, formando traiettorie. La libreria tf-agents fornisce un driver chiamato DynamicEpisodeDriver, che raccoglie i passaggi fino alla fine di un episodio. Il driver aggiorna gli osservatori, incluso un buffer di risposta.
Per archiviare i dati, possiamo utilizzare il TFUniformReplayBuffer comunemente usato dalla libreria tf-agents. Definiamo le specifiche degli elementi di dati che il buffer memorizzerà, la dimensione del batch e la lunghezza massima di ciascun segmento del batch.
Una volta completata la fase di raccolta dei dati, possiamo addestrare il nostro agente. L'agente richiede l'accesso al buffer di riproduzione. Creiamo una pipeline tf.data.Dataset per fornire i dati all'agente. Ogni riga del buffer di riproduzione memorizza una singola traiettoria, ma l'agente DQN necessita sia delle osservazioni correnti che di quelle successive per calcolare la perdita. Pertanto, impostiamo il parametro num_steps su 2, che consente alla pipeline del set di dati di campionare due righe per ogni elemento nel batch.
A questo punto, abbiamo tutto a posto per addestrare due agenti DQN sugli stessi dati e valutare le loro prestazioni. Un agente utilizza una semplice rete Q, mentre l'altro utilizza una rete QRNN. Entrambi gli agenti vengono addestrati utilizzando 200 giorni di dati sui prezzi storici.
Dopo 700 passaggi di addestramento, osserviamo che il semplice agente Q-Network non ha imparato molto e mostra per lo più un rendimento medio negativo. Tuttavia, l'agente QRNNNetwork mostra per lo più rendimenti medi positivi. Questo risultato è in linea con le aspettative, poiché l'agente RNN può acquisire alcune dinamiche nei dati e apprendere più velocemente.
Mentre questo semplice esperimento fornisce qualche speranza per l'utilizzo dell'apprendimento per rinforzo nella creazione di un agente redditizio, ci sono ancora altre metriche da considerare per valutare le prestazioni dell'agente. Li esploreremo in un video futuro.
Grazie per aver guardato e ci vediamo nel prossimo episodio.
Parte IX Rinforzo Imparare la Strategia di Trading. DQN: test della strategia di trading basata sulla politica dell'agente
Parte IX Rinforzo Imparare la Strategia di Trading. DQN: test della strategia di trading basata sulla politica dell'agente
Sono entusiasta di annunciare che abbiamo raggiunto una pietra miliare significativa nel nostro viaggio: testare la nostra strategia. A tale scopo, utilizzeremo un semplice framework Python di backtesting per condurre i nostri test. Per iniziare, puoi installare il framework eseguendo il comando "pip install" seguito dal nome del framework.
L'autore del framework ha fornito un semplice esempio che dimostra come usarlo in modo efficace. Tuttavia, prima di immergerci in questo, dobbiamo implementare la nostra strategia. Iniziamo inizializzando e definendo tutte le variabili di cui avremo bisogno per la nostra strategia.
Un aspetto interessante è che possiamo caricare la nostra politica salvata utilizzando l'API TensorFlow. Poiché stiamo utilizzando una rete QRNN, dobbiamo ottenere lo stato iniziale della politica. Di conseguenza, abbiamo implementato la funzione di inizializzazione. Ora è il momento di implementare la funzione "next", che verrà chiamata per ogni nuovo passaggio. All'inizio, dobbiamo raccogliere i dati per i primi 10 giorni e, successivamente, possiamo alimentare il nostro dizionario di osservazione. Ad ogni passaggio, aggiorniamo l'osservazione e la trasmettiamo alla policy.
Una volta creato il dizionario di osservazione, dobbiamo creare un oggetto timestep poiché il nostro modello di policy lo richiede come input. Per facilitare questo processo, ho creato una semplice funzione che converte i nostri dati di osservazione nell'oggetto timestep. Gli elementi cruciali qui sono i dati di osservazione e step_type. Dopo aver ottenuto il nostro oggetto timestep, possiamo recuperare un'azione dalla policy. Come puoi vedere, la funzione "runPolicy" reimposta lo stato della politica se step_type è uguale a 0 e restituisce l'azione e il nuovo policy_state.
Successivamente, dobbiamo aggiornare i nostri stati di posizione ed eseguire l'azione. Infine, al termine della funzione "next", incrementiamo il contatore e resettiamo tutto agli stati iniziali per simulare l'inizio di un nuovo episodio. Grande! Abbiamo implementato con successo la nostra strategia. Ora, abbiamo bisogno di alcuni dati a scopo di test. Possiamo utilizzare la libreria panda_datareader per recuperare i dati giornalieri da Yahoo Finance. Iniziamo testando la nostra strategia sul titolo Intel, utilizzando i dati storici di un anno.
Creiamo un oggetto backtest e iniziamo i test. I risultati del test mostrano un rendimento del 106%, il che è impressionante. Tuttavia, è importante notare che il framework di backtesting avvia i calcoli dal 100%, il che significa che il nostro rendimento effettivo è solo del 6%. Tuttavia, questo non è un cattivo risultato considerando che la nostra politica non è stata ampiamente addestrata. Per fornire una valutazione più completa, testiamo anche la nostra strategia sui titoli AMD. Come puoi vedere, il risultato per AMD mostra un calo di circa il 40%. Pertanto, possiamo confrontare le prestazioni della nostra strategia fianco a fianco sui titoli AMD e Intel.
Ora sai come utilizzare la policy dell'agente con un framework di backtesting. Allo stesso modo, se stai usando Python per il tuo vero ambiente di trading, puoi utilizzare la politica nello stesso modo. Tuttavia, per coloro che utilizzano altri linguaggi, è possibile distribuire la policy utilizzando il framework Flask e accedervi tramite un'API REST.
Spero che tu abbia trovato questi video interessanti e istruttivi. Se l'avete fatto, prendete in considerazione la possibilità di iscrivervi e ci vediamo nel prossimo episodio.
Cos'è un sistema di trading quantitativo? Struttura e descrizione.
Cos'è un sistema di trading quantitativo? Struttura e descrizione.
Ciao a tutti! Spero stiate tutti bene. È passato un po' di tempo dall'ultima volta che ho pubblicato un video, ma voglio assicurarti che non mi sono dimenticato di te. Oggi sono entusiasta di iniziare un nuovo e interessante argomento: l'architettura software di un sistema di trading automatizzato.
Prima di approfondire i dettagli dell'architettura del software, capiamo innanzitutto cos'è un sistema di trading e in cosa consiste. In questo video esploreremo la struttura e gli elementi di un sistema di trading automatizzato. Ora, come dice il proverbio, "Non c'è niente di nuovo sotto il sole". Quando ho iniziato il mio viaggio in questo campo, ero alla ricerca di una descrizione ben strutturata di un sistema di trading. Volevo qualcosa che rendesse facile capire quali blocchi implementare e come creare una solida soluzione software.
Mi sono imbattuto in un libro di Rishi K. Narang intitolato "Inside the Black Box", in cui descrive un sistema quantitativo composto da cinque blocchi comuni: il modello alfa, il modello di rischio, il modello di costo di transazione, il modello di costruzione del portafoglio e il modello di esecuzione. Inoltre, c'è un altro blocco essenziale: i dati.
Diamo un'occhiata più da vicino a questa struttura, a partire dal blocco dati. Sebbene il blocco dati non sia tecnicamente una parte del sistema di trading, svolge un ruolo vitale come l'ossigeno su cui fanno affidamento tutti i componenti del sistema. Il blocco dati comprende vari tipi di dati richiesti dal sistema di trading. Questi dati possono provenire da diverse fonti come borse, autorità di regolamentazione, agenzie di stampa e altre fonti rilevanti come dati microeconomici, commissioni di broker o informazioni sul portafoglio.
Ora che abbiamo compreso il blocco dati, esploriamo gli elementi del sistema commerciale e le relazioni tra di essi. Nel diagramma puoi vedere le frecce che rappresentano il flusso di informazioni. Il modello alfa, il modello del rischio e il modello del costo di transazione non prendono decisioni finali; invece, forniscono informazioni al modello di costruzione del portafoglio, che, a sua volta, attiva il modello di esecuzione. È importante notare che esistono strategie in cui è presente solo un sottoinsieme di questi elementi e le relazioni tra gli elementi possono variare. Tuttavia, questa struttura ci offre una visione olistica dei principali elementi di un sistema di trading.
Il primo elemento di questa struttura è il modello alfa. Il modello alfa rappresenta l'idea o la strategia di trading progettata per prevedere i risultati futuri. In genere, l'output di questo modello è una previsione di rendimento o di direzione. Esistono due tipi ben noti di modelli di trading: modelli tecnici basati su dati sui prezzi e analisi tecnica e modelli fondamentali che utilizzano dati finanziari e analisi fondamentale. Possiamo anche avere modelli ibridi che combinano aspetti di entrambi. Indipendentemente dalla complessità, lo scopo principale del modello alfa è fornire consulenza sotto forma di previsione.
Successivamente, abbiamo il modello di rischio. Il modello di rischio è progettato per aiutare a ridurre o minimizzare l'esposizione a fattori che potrebbero portare a perdite. I modelli di rischio possono essere classificati in due tipi. Il primo tipo si concentra sul dimensionamento della posizione per ridurre i rischi, impiegando strategie come hard sizing o funzioni complesse. L'output di questo tipo di modello di rischio è la dimensione della posizione. Il secondo tipo di modello di rischio mira a mitigare tipi specifici di rischi, come il rischio di direzione del mercato. In tali casi, il modello può suggerire una posizione di copertura come output.
Il terzo elemento è il modello dei costi di transazione. Questo modello fornisce informazioni sul costo associato all'esecuzione di un'operazione. Ci sono tre costi principali: commissioni e commissioni, slippage e impatto sul mercato. I modelli di costo di transazione possono variare da modelli semplici che restituiscono un valore di costo fisso a quelli più complessi, come le funzioni di costo quadratico, che mirano a prevedere il costo effettivo nel modo più accurato possibile. Il grafico seguente mostra come possono funzionare diverse funzioni di costo.
Una volta che abbiamo tutti gli elementi che forniscono informazioni, si passa al modello di costruzione del portafoglio. Questo modello prende input dal modello alfa, dal modello di rischio e dal modello di costo di transazione e decide come allocare i fondi tra le diverse attività. Ha lo scopo di costruire un portafoglio basato su una funzione obiettivo. Esistono due tipi principali di modelli di costruzione del portafoglio: modelli basati su regole (ad esempio, pari pesi, pari rischio, metodi dell'albero decisionale) e ottimizzatori di portafoglio. Quest'ultimo comporta l'ottimizzazione di una funzione obiettivo per ottenere un'asset allocation più ottimale nel portafoglio.
Infine, abbiamo il modello di esecuzione, che riceve informazioni dal modello di costruzione del portafoglio e si concentra sull'esecuzione degli ordini al miglior prezzo possibile. Esistono vari tipi di modelli di esecuzione, che vanno da semplici ordini di mercato o con limite a quelli più complessi che analizzano la microstruttura del mercato e utilizzano algoritmi di apprendimento automatico.
Con questo si conclude la breve descrizione dei principali elementi di un sistema di scambio quantitativo. Spero che questa panoramica ti abbia fornito una migliore comprensione della struttura del sistema di trading e di come funziona in generale.
Nei prossimi video proverò a creare un'architettura di sistema software basata su questa descrizione. Se trovi interessante questo argomento, considera di iscriverti al canale per futuri aggiornamenti. Grazie per aver guardato e ci vediamo nel prossimo video.