In questo articolo descriviamo come usare i grafici Heikin Ashi con 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. Nell’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.
Grafici Heikin Ashi con QuantConnect
Usare i grafici Heikin Ashi con Quantconnect differisce da altre piattaforme come Tradingview e Backtrader. Su QuantConnect accediamo ai dati di Heikin Ashi 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 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.
Non significa che le altre piattaforme siano sbagliate o abbiano problemi ma significa che gli utenti devono esserne consapevoli e adattare il loro codice in modo appropriato. In 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.
Grafico a candele Heikin Ashi
Gli utenti che cercano di visualizzare i grafici a candele Heikin Ashi con Quantconnect 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 con Quantconnect.
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.
Provare con i log!
Può essere utile, dove possibile, usare la funzione di log (self.Log()) anche se è una delle possibili soluzioni per la visualizzazione. A meno che tu non stia cercando pattern visivi, puoi verificare tutto ciò di cui hai bisogno tramite il log, quindi è un buon momento per iniziare a sentirsi a proprio agio con i log.
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.
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! 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, per usare i grafici Heikin Ashi con Quantconnect, possiamo tracciare ogni punto-data dall’indicatore su un semplice grafico a linee. Ciò si tradurrà in un grafico che assomiglia a questo:
Personalmente, lo trovo un po’ difficile da leggere e preferirei guardare un file di log.
Suggerimento 2 – Grafici a candele
L’opzione successiva per usare i grafici Heikin Ashi con Quantconnect, è creare un grafico personalizzato e impostare una serie di dati che utilizza SeriesType.Candle, anche se 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.
Notiamo 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 per come usare i grafici Heikin Ashi con Quantconnect è stato raccomandato nei forum della community in diverse occasioni e quindi vale la pena menzionarlo! Con questo metodo, usiamo indicatori di dispersione per tracciare i dati OHLC.
Suggerimento 4 – Misto
Nell’esempio finale su come usare i grafici Heikin Ashi con Quantconnect 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: https://www.quantconnect.com/datasets/
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.
Vediamo che nel codice di esempi i metodi (funzioni) Initialize()e OnData() sono stati codificati in modo da supportare più asset, quindi se aggiungiamo un secondo simbolo nella riga self.Equities = ["AAPL"], la strategia analizza entrambi i simboli e crea i grafici per ciascuno ticker. A causa del numero di grafici utilizzati negli esempi, è probabile che vengano raggiunti i limiti di visualizzazione quindi è 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, quindi 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:
- Se stiamo comprando/vendendo al momento giusto.
- 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:
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.
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.
Codice completo
In questo articolo abbiamo descritto come usare i grafici Heikin Ashi con Quantconnect. Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/QuantConnect
