In questo articolo descriviamo come simulare le posizioni in un indicatore di Tradingview per il trading algoritmico, una delle tecniche di base necessarie per simulare la funzionalità della strategia negli “study” script, cioè gli indicatori di Tradingview.
Sempre più persone sono interessate ad usare Tradingview come strumento per automatizzare completamente le strategie. Anche se è qualcosa che non raccomandiamo (per le motivazioni che approfondiamo più avanti), ci sono alcuni argomenti a favore. In particolare, gli utenti possono continuare a utilizzare una piattaforma con cui hanno familiarità. Inoltre, non hanno bisogno di imparare un nuovo linguaggio di programmazione e non hanno bisogno di dedicare tempo ed energia al porting della loro strategia su un’altra piattaforma. Dopotutto, molti utenti di Tradingview e di script pine non sono sviluppatori di professione. Se ti ritrovi nella descrizione delle ultime frasi, allora questo articolo è per te.
Simulare le posizioni di un indicatore
Innanzitutto, per chi non lo sapesse, dobbiamo sottolineare che, al momento in cui scriviamo, Tradingview non supporta ufficialmente il trading automatico in alcun modo. Questo può essere sorprendente per alcuni utenti. Vedono che Tradingview può connettersi ai broker e consentire loro di effettuare operazioni manualmente, quindi sono portati a pensare che possono usare pine-script per automatizzare il trading. Al momento non esiste alcun collegamento tra pine-script pine e i broker supportati.
Dato che esiste una chiara domanda di mercato per il trading automatico tramite Tradingview, sono emersi molti tipologie di servizi di terze parti o estensioni del browser, come Autoview. Questi strumenti sfruttano generalmente il sistema di alert di Tradingview per eseguire le operazioni. Monitorano le notifiche del browser o gli avvisi e-mail e quindi leggono il contenuto del messaggio alertcondition(). In questo modo il servizio riceve da tradingview i segnali di acquisto o vendita e quindi si collega al broker ed esegue il trade in automatico.
Ora che conosciamo la logica base, sappiamo che dobbiamo usare gli alert di Tradingview, e quindi capire di cosa abbiamo bisogno per usaore uno script study() e, in definitiva, perché dobbiamo simulare le funzionalità dello script strategy(). Il problema è che (al momento della scrittura) non possiamo aggiungere alert a uno script strategy. Gli alert possono essere aggiunti solo agli script study, che sono gli indicatori. Quindi dobbiamo rielaborare le strategie come indicatori.
I limiti dello script Study()
Proprio come uno script strategy() non ha accesso alla funzione alertcondition(), gli script study() non hanno accesso a tutta una serie di variabili e funzioni specifiche della strategia, descritte in alcuni dei precedenti articoli. Ad esempio, lo script Study() non includono:
- strategy.position_size
- strategy.position_avg_price
- strategy.open_profit
- strategy.entry()
- strategy.exit()
Per citarne solo alcuni…
Immaginiamo di voler usare uno stoploss ma non abbiamo accesso alla funzione strategy.exit(), quindi dobbiamo personalmente simulare l’invio di un ordine al mercato e monitorarlo per vedere quando sarebbe eseguito. Questo approccio è necessario per qualsiasi altra variabile incorporata che vogliamo usare. Vogliamo conoscere il prezzo medio? Bene, se consentiamo il ridimensionamento, dobbiamo tenere traccia del prezzo di entrata e delle dimensioni per ogni acquisto/vendita prima che possa di poter calcolare la nuova posizione.
Come possiamo immaginare, più complessa è la strategia, più difficile sarà trasformarla in un indicatore. Per questo motivo, questo articolo non può approfondire tutti gli strumenti previsti dallo script strategy, ma possiamo descrivere i principali. Quindi, come suggerisce il titolo, diamo un’occhiata alla simulazione le posizioni se siamo a mercato.
Alcuni consigli e punti di attenzione
Personalmente, non sono un fan dell’utilizzo di Tradingview per eseguire strategie dal vivo e fare trading con denaro reale. Ci sono una serie di motivi, tra cui:
- Il trading dal vivo non è ufficialmente supportato. Tradingview può modificare la piattaforma in qualsiasi momento, il che potrebbe compromettere la compatibilità con i servizi/estensioni.
- Il sistema di alert non è stato progettato per il trading automatico. Non possiamo aspettarci avvisi immediati. Non possiamo aspettarci nemmeno di ricevere avvisi ogni volta.
- Richiede plug-in di terze parti per colmare il divario tra Tradingview e il broker/exchange, quindi abbiamo un ulteriore fonte di errori e ritardi.
- Non c’è comunicazione tra il broker e Tradingview. Lo script
study()non può sapere se l’ordine è stato evaso o rifiutato o ha perso qualche dollaro. Presume che l’ordine è stato completamente eseguito e continua. Non ha idea se la posizione è stata liquidata o chiusa dal broker. L’elenco può andare avanti… - È davvero facile perdere la sincronizzazione tra lo script
study()e cosa accade realmente nel conto. Questo può essere molto pericoloso per il portafoglio. Se lo scriptstudy()pensa di essere flat quando invece siamo in posizione, possiamo finire di avere il doppio della dimensione prevista (più rischio) a un prezzo di carico medio più alto. O forse abbiamo una posizione short invece di una posizione long.
Quando sono in gioco soldi veri, è meglio usare strumenti creati per tale scopo. Usare Tradingview in combinazione con servizi di terze parti può portare a termine il lavoro, ma alla fine potremmo ottenere più delusioni che soddisfazioni.
Simulazione delle posizioni
Se stai ancora leggendo e non sei stato convinto dei rischi, vediamo come simulare le posizioni in un indicatore di Tradingview! Il codice seguente fornisce un semplice modo per simulare le posizioni. Esistono molti modi e man mano che le strategie diventano più complesse, questo metodo potrebbe non essere più adatto. Questo script prevede che abbiamo una sola entrata alla volta (nessuna piramidazione/ridimensionamento).
Allora perché simulare le posizioni? L’obiettivo è garantire di ricevere un avviso solo quando una strategia comprerebbe e venderebbe. Un problema con questo approccio è che le condizioni di acquisto e vendita possono essere true mentre siamo in posizione, quindi si attiva un nuovo allert mentre non vogliamo acquistare o vendere di nuovo. Pertanto, dobbiamo prevedere di impedire l’attivazione di alert indesiderati.
Strategia di base
Per descrivere questo problema, prendiamo una semplice strategia. Una volta convertito in uno studio, dobbiamo verificare se si attivano due o più alert long o short consecutivi. Negli esempi seguenti, tracciamo un indicatore sul grafico ogni volta che alertcondition() è vera, in modo da vedere quando si attiva un alerto.
La strategia di base che usiamo è disponibile come una delle strategie integrate di Tradingview. Entra in una posizione dopo il rilevamento di uno specifico numero di candele verdi o rosse consecutive. Dato che una serie consecutiva di candele verde/rosse è abbastanza comune, dovrebbe essere perfetta per i nostri scopo.
//@version=3
strategy("Consecutive Up/Down Strategy", overlay=true)
consecutiveBarsUp = input(3)
consecutiveBarsDown = input(3)
price = close
ups = 0.0
ups := price > price[1] ? nz(ups[1]) + 1 : 0
dns = 0.0
dns := price < price[1] ? nz(dns[1]) + 1 : 0
if (ups >= consecutiveBarsUp)
strategy.entry("ConsUpLE", strategy.long, comment="ConsUpLE")
if (dns >= consecutiveBarsDown)
strategy.entry("ConsDnSE", strategy.short, comment="ConsUpLE")
Conversione in Study
La conversione è molto semplice. Dobbiamo prevedere i seguenti passi:
- Sostituire
strategy()constudy() - Rimuovere le chiamate
strategy.entry() - Aggiungiere
alertconditions()quandoups >= consecutiveBarsUpedns >= consecutiveBarsDown - Tracciare gli indicatori sul grafico quando le condizioni di alert sono soddisfatte.
Il codice
//@version=3
study("Consecutive Up/Down Study", overlay=true)
consecutiveBarsUp = input(3)
consecutiveBarsDown = input(3)
price = close
ups = 0.0
ups := price > price[1] ? nz(ups[1]) + 1 : 0
dns = 0.0
dns := price < price[1] ? nz(dns[1]) + 1 : 0
alertcondition(ups >= consecutiveBarsUp)
alertcondition(dns >= consecutiveBarsDown)
plotshape(ups >= consecutiveBarsUp, location=location.belowbar, style=shape.arrowup, color=green)
plotshape(dns >= consecutiveBarsDown, location=location.abovebar, style=shape.arrowdown, color=red)
Quindi, dopo la semplice conversione, possiamo posizionare sul grafico contemporaneamente la strategia di base e l’indicatore studio. Confrontando i due, diventa immediatamente evidente che qualcosa non funziona.
Nel grafico precedente, abbiamo aggiunto contemporaneamente sia la strategia di base che la sua conversione in un indicatore. Si vedono chiaramente le strategie, le entrate e le uscite, inoltre abbiamo le frecce verdi e rosse che mostrano le condizioni di alert previste nello script study. Possiamo vedere che lo studio attiva allert molto, molto più frequentemente di quanto la strategia apra o chiuda le posizioni. Questo non è l’ideale.
Una semplice soluzione
Di seguito è riportato il codice finale su come simulare le posizioni in un indicatore di Tradingview, dove aggiungiamo alcuni semplici controlli aggiuntivi per vedere se siamo in posizione o meno. Quindi attiviamo un alert long solo se siamo short o flat. Allo stesso modo, consentiamo solo un alert short se siamo long o flat.
//@version=3
study("Consecutive Up/Down Study", overlay=true)
consecutiveBarsUp = input(3)
consecutiveBarsDown = input(3)
price = close
ups = 0.0
ups := price > price[1] ? nz(ups[1]) + 1 : 0
dns = 0.0
dns := price < price[1] ? nz(dns[1]) + 1 : 0
goLong = ups >= consecutiveBarsUp
goShort = dns >= consecutiveBarsDown
inLongPosition = na
inLongPosition := goLong[1] ? true : goShort[1] ? false : inLongPosition[1]
inShortPosition = na
inShortPosition:= goShort[1] ? true : goLong[1] ? false : inShortPosition[1]
flat = na
flat := not inLongPosition and not inShortPosition
alertcondition(goLong and (inShortPosition or flat))
alertcondition(goShort and (inLongPosition or flat))
plotshape(goLong and (inShortPosition or flat), location=location.belowbar, style=shape.arrowup, color=green)
plotshape(goShort and (inLongPosition or flat), location=location.abovebar, style=shape.arrowdown, color=red)
//plot(strategy.equity, title="equity", color=red, linewidth=2, style=areabr)
Quando tracciamo il codice sopra sui grafici, possiamo immediatamente vedere la differenza.
Si potrebbe sottolineare che gli alert sono in anticipo o che non siano sincronizzati con la strategia! Tuttavia, dobbiamo ricordarci che un normale ordine di mercato è eseguito all’apertura della barra successiva. In altre parole, sulla strategia le condizioni sono vere sulla barra precedente a quella dove vediamo i marcatori Long/Short sul grafico. Vogliamo lo stesso con i nostri avvisi. Dovrebbero essere attivati alla chiusura della barra in modo che possiamo provare ad aprire una posizione il più vicino possibile all’apertura della barra successiva.
Codice completo
In questo articolo abbiamo decritto come simulare le posizioni in un indicatore con Tradingview per il trading algoritmico, Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/TradingView
