QuantConnect-lavorare-dati-Heikin-Ashi

QuantConnect: lavorare con i dati Heikin Ashi

Sommario

SCRIVIMI SU TELEGRAM

Per informazioni, suggerimenti, collaborazioni...

Se è la prima volta che atterri su DataTrading, BENVENUTO!

Lascia che mi presenti. Sono Gianluca, ingegnere, trekker e appassionato di coding, finanza e trading. Leggi la mia storia.

Ho creato DataTrading per aiutare le altre persone ad utilizzare nuovi approcci e nuovi strumenti, ed applicarli correttamente al mondo del trading.

DataTrading vuole essere un punto di ritrovo per scambiare esperienze, opinioni ed idee.

TUTORIAL

Questo articolo descrive come lavorare con i dati di Heiken Ashi in QuantConnect. Descriviamo come utilizzare i dati di Heikin Ashi in una strategia di trading algoritmico, esaminiamo alcune opzioni di visualizzazione del grafico ed implementiamo una semplice strategia che può essere utilizzata come base per futuri progetti. Non è la prima volta che tocchiamo questo argomento. In precedenza, abbiamo descritto come lavorare con i dati Heikin Ashi su Backtrader. In quell’articolo, abbiamo anche introdotto il grafico con candele Heikin Ashi e come interpretarlo. Quelle parti introduttive non sono specifiche per backtrader, quindi tutti i lettori che non conoscono le candele Heiken Ashi possono avere beneficio dalla lettura dei primi paragrafi.

Heiken Ashi su QuantConnect

L’approccio di QuantConnect alla gestione dei dati di Heikin Ashi differisce da altre piattaforme come Tradingview e Backtrader. Su QuantConnect accediamo ai dati di Heikinashi tramite un indicatore. Questa decisione progettuale ha molto senso. Dopotutto, le candele Heiken Ashi sono un derivato dei prezzi reali proprio come qualsiasi altro indicatore. Al contrario, su altre piattaforme, i dati di Heiken Ashi vengono forniti come feed di dati. In altre parole, i dati OHLC sono convertiti nella versione Heikin Ashi di OHLC. Con i dati OHLC, i principianti ottengono spesso risultati  errati e aspettative non realistiche. Questo perché quando i prezzi di Heikin Ashi sono forniti come feed di dati, il motore di backtest ha solo questi prezzi come riferimento. A sua volta, questo significa che i livelli di esecuzione degli ordini e i calcoli di profitti/perdite si basano su prezzi che non sono mai esistiti. Questo non significa che le altre piattaforme siano sbagliate o abbiano problemi. Significa solo che gli utenti devono esserne consapevoli e adattare il loro codice in modo appropriato. Su QuantConnect il principiante non deve nemmeno preoccuparsi di questo. I dati arrivo come un insieme di valori  di indicatori. Tutti gli ordini eseguiti e i calcoli PnL ecc. saranno sempre calcolati dal feed di dati dei prezzi reali!

Aggiungere gli indicatori Heikin Ashi

Come detto in precedenza, per utilizzare i dati di Heiken Ashi su QuantConnect dobbiamo creare un indicatore. Lo facciamo nello stesso modo in cui abbiamo creato l’indicatore RSI nell’articolo del primo script. Consultando l’API di Quantconnect scopriamo che la classe HeikinAshi() è disponibile nel nodo degli indicatori.

QuantConnect-Heikin-Ashi-in-QuantConnect-API

Grafico a candele Heikinashi

Gli utenti che cercano di visualizzare i grafici a candele Heikin Ashi potrebbero arrivare a questo articolo per gentile concessione di Google. Se sei in questo gruppo, possiamo almeno farti risparmiare un po’ di tempo  dicendoti che una soluzione non esiste. Al momento in cui scrivo non c’è supporto per tracciare candele Heikin Ashi.

Sebbene QuantConnect supporti la creazione di grafici personalizzati, non è una piattaforma di creazione di grafici di trading. Pertanto, gli utenti non possono aspettarsi di avere le stesse capacità e funzionalità per la creazione di grafici di Tradingview. Detto questo, ci sono alcune cose che possiamo fare per visualizzare i dati Heikinashi. Di seguito descriviamo quattro  casi. Questi non sono le uniche opzioni, ma dovrebbero fornire la base per utili personalizzazioni.

Prova con i log!

Sebbene questo non sia uno delle possibili soluzioni per la visualizzazione, dove possibile è utile provare a utilizzare la funzione di  log (self.Log()). A meno che tu non stia cercando pattern visivi, puoi verificare tutto ciò di cui hai bisogno tramite il log. Pertanto, questo è un buon momento per iniziare a sentirsi a proprio agio con i log. Inoltre, come descritto nell’articolo relativo alla visualizzazione dei grafici, QuantConnect applica dei limiti ai grafici, non è pratico tracciare ogni  tick nei nostri algoritmi. I grafici dovrebbero essere selezionati con saggezza e visualizzati solo quando necessario.

QuantConnect-RSI-Plotting-Plotting-Limit-Exceeded-Terminal

Se sei una persona visiva e ti piace vedere i grafici per generare idee di sviluppo, allora non c’è nulla di male nell’usare una piattaforma di creazione di grafici come Tradingview insieme a QuantConnect. Usa la piattaforma per la creazione di grafici come blocco note e poi torna su QuantConnect quando sei pronto per mettere in pratica un’idea! Quindi, senza ulteriori indugi, passiamo ai nostri suggerimenti. Nota: tutti i suggerimenti mostrati di seguito saranno contenuti nel codice della strategia finale.

Suggerimento 1 – Grafici a linee

Innanzitutto, possiamo tracciare ogni punto-data dall’indicatore su un semplice grafico a linee. Ciò si tradurrà in un grafico che assomiglia a questo:

QuantConnect-Heikin-Ashi-Line-Chart

Personalmente, lo trovo un po’ difficile da leggere e preferirei guardare un file di log.

Suggerimento 2 – Grafici a candele

L’opzione successiva è creare un grafico personalizzato e impostare una serie di dati che utilizza  SeriesType.Candle. Da notato, tuttavia, che questo non produce una candela OHLC a cui siamo abituati sulle piattaforme di analisi grafica. In questo caso, produce qualcosa che rappresenta più da vicino la  curva equity.

QuantConnect-Heikin-Ashi-Candle-Chart

DA notare che ogni candela rappresenta la variazione di prezzo tra 2 giorni. Possiamo vederlo sull’asse x. Si muove in intervalli di 2 giorni.

Suggerimento 3 – Grafici a dispersione

Il terzo suggerimento è stato raccomandato nei forum della community in diverse occasioni e quindi vale la pena menzionarlo! Con questo metodo, utilizziamo indicatori di dispersione per tracciare i dati OHLC.

QuantConnect-Heikin-Ashi-Scatter-Chart

Suggerimento 4 – Misto

Nel grafico finale mescoliamo grafici a linee e a dispersione per ottenere un bel mix di informazioni. I cerchi sulla linea Price indicano se abbiamo chiuso al rialzo o al ribasso. Cioè se la candela Heiken Ashi è verde o rossa. Oltre a questo, aggiungiamo due grafici a dispersione per mostrare i massimi e i minimi relativi. Ciò si traduce in un grafico che assomiglia a questo:

Il codice

				
					
### <summary>
### Simple RSI Strategy intended to provide a minimal algorithm example using
### one indicator
### </summary>

# region imports
from AlgorithmImports import *
from System.Drawing import Color
# endregion

class RSIAlgorithm(QCAlgorithm):

    def Initialize(self):
        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''
        
        # Impostazione dei parametri della strategia
        self.SetStartDate(2014,12, 1)   # Data Inizio
        self.SetEndDate(2015,1,1)       # Data Fine
        self.SetCash(10000)             # Capitale Iniziale
        
        self.Equities = ["AAPL"]
        
        self.HK = dict() # Creare un dizionario per memorizzare gli indicatori HK
        
        for Equity in self.Equities:
            # Altri simbolo su: http://quantconnect.com/data
            self.AddEquity(Equity, Resolution.Daily)
            self.HK[Equity] = self.HeikinAshi(Equity, Resolution.Daily)
            
            
            # Suggerimento 1: Grafico a linea
            # --------------------------------------
            # Nota: Questo è stato commentato in quanto 
            #       siamo limitati a 10 serie per backtest. 
            #       Per testare, decommenta le righe 
            #       sottostanti e poi commenta il 
            #       suggerimento 3 o 4.
            # ---------------------------------------
            #self.PlotIndicator(
            #    Equity + " - Line",
            #    self.HK[Equity].Open,
            #    self.HK[Equity].High,
            #    self.HK[Equity].Low,
            #    self.HK[Equity].Close
            #    )
            
            # Suggerimento 2: Grafico a candele
            # ---------------------------------------
            CandChart = Chart(Equity + "- Candle", ChartType.Stacked)
            CandChart.AddSeries(Series('Heikinashi', SeriesType.Candle))
            self.AddChart(CandChart)
            
            # Suggerimento 3: Grafico Scatter 
            # ---------------------------------------
            ScatPlot = Chart(Equity + "- X", ChartType.Stacked)
            ScatPlot.AddSeries(Series('Open',  SeriesType.Scatter, '$', Color.Black, ScatterMarkerSymbol.Circle))
            ScatPlot.AddSeries(Series('High',  SeriesType.Scatter, '$', Color.Green, ScatterMarkerSymbol.Triangle))
            ScatPlot.AddSeries(Series('Low',   SeriesType.Scatter, '$', Color.Red,   ScatterMarkerSymbol.TriangleDown))
            ScatPlot.AddSeries(Series('Close', SeriesType.Scatter, '$', Color.Black, ScatterMarkerSymbol.Square))
            self.AddChart(ScatPlot)
            
            # Suggerimento 4: Grafico Misto
            # ---------------------------------------
            SAPlot = Chart(Equity + "- Mix", ChartType.Stacked)
            SAPlot.AddSeries(Series('Price', SeriesType.Line, "$", Color.Black))
            SAPlot.AddSeries(Series('Bullish', SeriesType.Scatter, "$", Color.Green, ScatterMarkerSymbol.Circle))
            SAPlot.AddSeries(Series('Bearish', SeriesType.Scatter, "$", Color.Red, ScatterMarkerSymbol.Circle))
            SAPlot.AddSeries(Series('Neutral', SeriesType.Scatter, "$", Color.Black, ScatterMarkerSymbol.Circle))
            SAPlot.AddSeries(Series('High',  SeriesType.Scatter, '$', Color.Black, ScatterMarkerSymbol.Triangle))
            SAPlot.AddSeries(Series('Low',   SeriesType.Scatter, '$', Color.Black,   ScatterMarkerSymbol.TriangleDown))
            self.AddChart(SAPlot)
            
            
    def OnData(self, data):
        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.

        Arguments:
            data: Slice object keyed by symbol containing the stock data
        '''
        
        for Equity in self.Equities:
            
            # Alias
            # -----------------------------------------------------------------
            
            # Heikin
            HK_O = self.HK[Equity].Open.Current.Value
            HK_H = self.HK[Equity].High.Current.Value
            HK_L = self.HK[Equity].Low.Current.Value
            HK_C = self.HK[Equity].Close.Current.Value
            HK_P = self.HK[Equity].Current.Price
            
            # OHLC
            O = data[Equity].Open
            H = data[Equity].High
            L = data[Equity].Low
            C = data[Equity].Close
            P = data[Equity].Price
            
            # -----------------------------------------------------------------
           
            # Heikin Sentiment
            # ---------------------------------------
            if HK_O < HK_C:
                HK_S = "Bull" 
            elif HK_O > HK_C:
                HK_S = "Bear"
            else:
                HK_S = "Neut"
     
            
            # Option 2: Grafico a Candele
            # ---------------------------------------
            self.Plot(Equity + "- Candle", 'Heikinashi',  HK_P)
            
            
            # Option 3: Grafico Scatter
            # ---------------------------------------
            self.Plot(Equity + "- X", 'Open', HK_O)
            self.Plot(Equity + "- X", 'High', HK_H)
            self.Plot(Equity + "- X", 'Low',  HK_L)
            self.Plot(Equity + "- X", 'Close', HK_C)
            
            # Option 4: Grafico Misto
            # ---------------------------------------
            self.Plot(Equity + "- Mix", 'Price', HK_P)
            self.Plot(Equity + "- Mix", 'High', HK_H)
            self.Plot(Equity + "- Mix", 'Low',  HK_L)
            if HK_S == "Bull":
                self.Plot(Equity + "- Mix", 'Bullish', HK_P)
            elif HK_S == "Bear":
                self.Plot(Equity + "- Mix", 'Bearish', HK_P)
            else:
                self.Plot(Equity + "- Mix", 'Neutral', HK_P)
                
            
            # Logging
            # -----------------------------------------------------------------
            
            self.Log("{0} OHLC   >> O: {1} H: {2} L:{3}, C:{4} | Price: {5}".format(Equity, O,H,L,C,P))
            self.Log("{0} Heikin >> O: {1} H: {2} L:{3}, C:{4} | Price: {5} | Sentiment: {6}".format(Equity, HK_O,HK_H,HK_L,HK_C,HK_P,HK_S))
            
            # Criteri Entrata / Uscita
            # -----------------------------------------------------------------
            
            # Controlo se siamo a mercato
            if not self.Portfolio.Invested:
                # Controlo se il HK sentiment è bullish
                if HK_S == "Bull":
                    
                    self.SetHoldings(Equity, 0.5)
            else:
               if HK_S == "Bear":
                   self.Liquidate(Equity)
				
			

La strategia è molto, molto semplice. Acquista semplicemente quando le candele Heikin sono rialziste (verdi) e vende quando diventano ribassiste (rosse). Come accennato nell’introduzione, il codice è pensato per essere utilizzato come base per costruire altre strategie. Da notare che nel codice di esempi i metodi (funzioni) Initialize()OnData() sono stati codificati in modo da supportare più asset. Pertanto, se aggiungiamo un secondo simbolo nella riga self.Equities = ["AAPL"], la strategia analizza entrambi i simboli e crea i grafici per ciascuno ticker. Da notare che a causa del numero di grafici utilizzati negli esempi, è probabile che vengano raggiunti i limiti di  visualizzazione. E’ consigliato limitarsi a 10 grafici di serie per backtest. È anche per questo motivo che il suggerimento 1 è completamente commentato.

Logging

Per mettere in pratica quanto descritto, all’esempio sono state aggiunte alcuni log di base. Riportiamo nel log i dati OHLC originali, i dati OHLC Heikin e il sentiment della candela. Questo è sufficiente per confrontare le differenze di prezzo e confermare che la nostra strategia sta aprendo e chiudendo le posizioni nei casi corretti.

Grafico: oggetti di identità!

Un potenziale Gotcha quando si lavora con gli indicatori Heiken Ashi è la possibilità di accedere agli ultimi valori degli indicatori in questo modo:

				
					HK_O = self.HK[Equity].Open
HK_H = self.HK[Equity].High
HK_L = self.HK[Equity].Low
HK_C = self.HK[Equity].Close
HK_P = self.HK[Equity].Current
				
			

Tuttavia, questi sembrano essere oggetti di tipo “Identità” e non possono essere visualizzati. Se proviamo a visualizzarli riceviamo il seguente errore:

Errore di runtime: il tentativo di accedere dinamicamente a un metodo che non esiste genera un’eccezione TypeError. Per evitare l’eccezione, assicurarsi che ogni tipo di parametro corrisponda a quelli richiesti dal metodo Plot. Controlla la documentazione dell’API. in OnData in main.py: riga 110 TypeError: nessun metodo corrisponde agli argomenti specificati per Plot (Open Stacktrace)

All’inizio può creare confusione perché se proviamo a stampare i valori utilizzando  self.Log(), i valori verranno convertiti in una stringa e li vediamo nel log. In quanto tale, possiamo chiederci quale sia il problema. Risparmiamo tempo e accediamo agli ultimi valori Current.Value come mostrato nel codice.

				
					HK_O = self.HK[Equity].Open.Current.Value
HK_H = self.HK[Equity].High.Current.Value
HK_L = self.HK[Equity].Low.Current.Value
HK_C = self.HK[Equity].Close.Current.Value
HK_P = self.HK[Equity].Prezzo.Corrente
				
			

Verifica dell’output

Dopo aver creato qualsiasi algoritmo, dobbiamo eseguire alcuni controlli per assicurarci che funzioni come previsto. Per quanto semplice possa essere la strategia, dovremmo comunque eseguire dei test. Errori di battitura possono facilmente insinuarsi e invalidare completamente il test. Inoltre, è una buona abitudine quando gli algoritmi diventano più complessi. I due elementi chiave che verifichiamo sono:

  1. Se stiamo comprando/vendendo al momento giusto.
  2. Ricontrollare l’affermazione precedente, secondo cui il motore LEAN utilizza sempre i prezzi reali per l’evasione degli ordini.

Acquisto/Vendita

Per verificare se stiamo acquistando e vendendo nei  casi corretti, possiamo studiare i log e confrontarli con l’elenco dei trade:

QuantConnect-Trade-Verification

Nell’immagine sopra, verifichiamo due cose. In primo luogo, che il sentiment sia corretto e in secondo luogo che solo quando il sentiment cambia inviamo ordini di acquisto/vendita.

L’ordine viene eseguito

Infine, verifichiamo che gli ordini siano effettuati con prezzi reali. Ancora una volta possiamo farlo confrontando il log con l’elenco dei trade.

QuantConnect-Fill-at-the-open-Real-prices

Qui possiamo vedere che il trade è completato all’apertura della barra successiva, come previsto. Inoltre, è eseguito con i prezzi OHLC reali  invece che i prezzi Heikin Ashi.

Scroll to Top
Torna su