Auf interne Preiskanäle basierende Look-up- und Look-Down-Strategie

Schriftsteller:ChaoZhang, Datum: 23.11.2023
Tags:

Übersicht

Diese Strategie nutzt interne Preiskanäle, um zukünftige Preistrends zu bestimmen, und gehört zu Trendfolgestrategien. Wenn die Preise eine bestimmte Anzahl interner Preisfluktuationskanäle bilden, wird sie als Trendumkehrsignal für lange oder kurze Einträge beurteilt.

Strategieprinzip

Wenn eine bestimmte Anzahl von Kerzen die Bedingung erfüllt, dass der höchste Preis niedriger ist als der höchste Preis der vorherigen Kerze und der niedrigste Preis höher ist als der niedrigste Preis der vorherigen Kerze, wird ein interner Preiskanal identifiziert.

Wenn ein interner Kanal identifiziert wird, beurteilt die Strategie auch die Richtung des Kanals. Wenn es sich um einen bullischen internen Kanal handelt, wird ein langes Eintrittssignal generiert. Wenn es sich um einen bärischen internen Kanal handelt, wird ein kurzes Eintrittssignal generiert. Daher handelt es sich um eine bidirektionale Handelsstrategie.

Um falsche Signale zu filtern, wird auch ein gleitender Durchschnittsindikator eingeführt. Tatsächliche Handelssignale werden nur generiert, wenn der Preis über oder unter der gleitenden Durchschnittslinie liegt. Dies kann fehlerhafte Trades in einem gewissen Maße in seitlichen Märkten vermeiden.

Nach dem Eintritt können Stop-Loss- und Take-Profit-Punkte auch nach der Wahl des Benutzers festgelegt werden. Es gibt drei verfügbare Stop-Loss-Methoden: Fix-Point Stop-Loss, ATR Stop-Loss, vorheriger höchster/niedrigster Stop-Loss. Der Take-Profit wird nach dem Risiko/Reward-Verhältnis festgelegt. Dies kann Gewinne bis zu einem gewissen Grad sperren und Risiken kontrollieren.

Analyse der Vorteile

Der größte Vorteil dieser Strategie ist ihre starke Fähigkeit, Trendumkehrpunkte zu identifizieren. Wenn die Preise eine bestimmte Anzahl von internen Kanälen bilden, signalisiert sie oft, dass eine relativ große Preisbewegung nach oben/nieder geschieht.

Darüber hinaus ist die Konfigurationsfähigkeit der Strategie selbst sehr stark. Benutzer können frei Parameter wie Anzahl der internen Kanäle, gleitender Durchschnittszyklus, Stop-Loss/Take-Profit-Methode usw. auswählen. Dies bietet große Flexibilität für verschiedene Produkte und Handelsstile.

Schließlich reduzieren auch die in der Strategie eingeführten Filter für gleitende Durchschnittswerte und Stop-Loss/Take-Profit-Einstellungen das Handelsrisiko erheblich, wodurch die Strategie an den Handel in verschiedenen Marktumgebungen angepasst werden kann.

Risikoanalyse

Das größte Risiko dieser Strategie ist die relativ hohe Wahrscheinlichkeit falscher Trendbeurteilungen. Interne Kanäle können Preisumkehrungen nicht vollständig bestimmen, es besteht eine gewisse Wahrscheinlichkeit von Fehleinschätzung. Wenn die ermittelte Menge unzureichend ist, können falsche Signale auftreten.

Darüber hinaus ist die Strategie in seitlichen oder volatilen Märkten völlig nutzlos. Wenn die Preise ohne einen Trend schwanken, wird die Strategie kontinuierlich falsche Signale erzeugen. Dies wird durch den Mechanismus der Strategie bestimmt.

Wenn der Stop-Loss schließlich zu konservativ eingestellt wird, kann die Strategie möglicherweise nicht in der Lage sein, Positionen lange genug zu halten, um Gewinne in wichtigen Trends zu erzielen.

Optimierungsrichtlinien

Der Optimierungsraum dieser Strategie ist noch recht groß.

Optimieren der Menge und der Muster der internen Kanäle. Testen Sie Handelswirkungen unter verschiedenen Mengen oder verschiedenen Kombinationsvereinbarungen.
Optimieren Sie den Zyklusparameter des gleitenden Durchschnitts, um die Trendrichtung besser zu bestimmen.
Fügen Sie andere Indikatorfilter hinzu, z. B. Bollinger-Bänder einführen und nur Handelssignale erzeugen, wenn die Preise die oberen oder unteren Schienen der Bande durchbrechen.
Optimieren Sie die Stop-Loss-/Take-Profit-Parameter, damit die Strategie Positionen länger halten kann.

Im Allgemeinen beruht die Existenz dieser Strategie auf der Richtigkeit ihrer Trendbeurteilung, sofern die Richtigkeit der Beurteilung in Verbindung mit geeigneten Risikomanagement-Einstellungen gewährleistet werden kann, kann ein effektiver algorithmischer Handel durchgeführt werden.

Schlussfolgerung

Zusammenfassend ist diese Strategie eine quantitative Handelsstrategie, die zukünftige Preistrends basierend auf internen Preiskanälen bestimmt. Sie kombiniert Trendfolgung und Trendumkehrungsschätzungsmethoden und hat bestimmte Vorteile. Aber es gibt auch Raum für Optimierungen, um spezifische Produkte und Handelsumgebungen zu erfüllen. Nach Parameteroptimierung kann sie zu einer der idealsten quantitativen Handelsstrategien werden.

/*backtest
start: 2023-12-03 00:00:00
end: 2023-12-10 00:00:00
period: 3m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// From "Day Trading Cryptocurrency 
// Strategies, Tactics, Mindset, and Tools Required To Build Your 
// New Income Stream"
// by Phil C. Senior

// "Inside bars are a two -bar pattern. They can indicate either a continuation of the 
// existing move or a reversal. A continuation occurs when there is no significant 
// support or resistance level in sight, while a reversal occurs close to a strong sup- 
// port or resistance level...
// ...A lot of traders are aware of inside bars but few manage to make money with 
// them. Why is this so? It goes back to interpreting price action. A lot of traders look 
// to trade in geometric ways. What I mean is that they search for fancy shapes on a 
// chart and think that this is what represents true price action. 
// This is not the case. A shape is just a shape. The formation by itself means 
// nothing unless underlying order flow backs it up. This is why it’s extremely impor- 
// tant that you look for inside bars when a trend is already in place. The best place to 
// look for them is in the beginning of trends."

// © tweakerID

//@version=4
strategy("Inside Bar Strategy w/ SL", 
     overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

i_NBars = input(defval=1, type=input.integer, title="# Of Inside Bars in pattern", options=[1, 2, 3, 4])
i_BarsDirection = input(false, title="Only trade using complete bullish or bearish patterns")
i_MAFilter = input(true, title="Use MA Trend Filter")
i_MALen = input(65, title="MA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=1, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(5, step=.1, title="ATR Multiple")
i_TPRRR = input(2, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR

// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na 
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na 
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR


// Strategy Stop
float LongStop = valuewhen(bought,low[1],0)*(1-i_PercIncrement)
float ShortStop = valuewhen(bought,high[1],0)*(1+i_PercIncrement)
float StratTP = na
float StratSTP = na

/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

MAFilter=close > sma(close, i_MALen)
plot(i_MAFilter ? sma(close, i_MALen) : na)
bullBar=close > open
bearBar=close < open
contbullBar=barssince(not bullBar) >= (i_NBars+1)
contbearBar=barssince(not bearBar) >= (i_NBars+1)

InsideBar(NBars) =>
    Inside1Bar=high < high[1] and low > low[1] 
    Inside2Bar=high < high[2] and low > low[2] and Inside1Bar
    Inside3Bar=high < high[3] and low > low[3] and Inside1Bar and Inside2Bar
    Inside4Bar=high < high[4] and low > low[4] and Inside1Bar and Inside2Bar and Inside3Bar
    if NBars == 1
        inside1Bar=Inside1Bar
        [inside1Bar]
    else if NBars == 2
        inside2Bar=Inside2Bar
        [inside2Bar]
    else if NBars == 3
        inside3Bar=Inside3Bar   
        [inside3Bar]
    else if NBars == 4
        inside4Bar=Inside4Bar
        [inside4Bar]
    else
        [na]
[insideBar] = InsideBar(i_NBars) 
    
bullInsideBar=bar_index > 40 and insideBar and bullBar 
     and (i_BarsDirection ? contbullBar : true) and (i_MAFilter ? MAFilter : true)
bearInsideBar=bar_index > 40 and insideBar and bearBar 
     and (i_BarsDirection ? contbearBar : true) and (i_MAFilter ? not MAFilter : true)

BUY = bullInsideBar
SELL = bearInsideBar

//Debugging Plots
plot(contbullBar ? 1:0, transp=100, title="contbullBar")
plot(contbearBar ? 1:0, transp=100, title="contbearBar")

//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)

SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP

//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
 -strategy.position_avg_price
trailOffset     = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
    tstop := high- trailOffset - dif
    if tstop<tstop[1]
        tstop:=tstop[1]
else
    tstop := na
StrailOffset     = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0 
 and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
    Ststop := low+ StrailOffset + Sdif
    if Ststop>Ststop[1]
        Ststop:=Ststop[1]
else
    Ststop := na

strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", size=size.auto)

Mehr