Stratégie de recherche et de recherche basée sur les canaux de prix internes

Auteur:ChaoZhang est là., Date: 2023-12-11 15h56 et 28h
Les étiquettes:

Résumé

Cette stratégie utilise des canaux de prix internes pour déterminer les tendances futures des prix et appartient aux stratégies de suivi des tendances. Lorsque les prix forment un certain nombre de canaux de fluctuation des prix internes, il est jugé comme un signal d'inversion de tendance pour faire des entrées longues ou courtes.

Principe de stratégie

La stratégie détermine la formation de canaux internes en fonction de la relation de taille entre les prix les plus élevés et les plus bas des deux bougies précédentes.

Lorsqu'un canal interne est identifié, la stratégie juge également la direction du canal. S'il s'agit d'un canal interne haussier, un signal d'entrée long est généré. S'il s'agit d'un canal interne baissier, un signal d'entrée court est généré. Par conséquent, il s'agit d'une stratégie de trading bidirectionnelle.

Pour filtrer les faux signaux, un indicateur de moyenne mobile est également introduit. Les signaux de trading réels ne sont générés que lorsque le prix est au-dessus ou en dessous de la ligne moyenne mobile. Cela peut éviter des transactions erronées dans une certaine mesure sur les marchés latéraux.

Après l'entrée, les points de stop-loss et de take-profit peuvent également être définis selon le choix de l'utilisateur. Il existe trois méthodes de stop loss disponibles: stop loss point fixe, stop loss ATR, stop loss précédent le plus élevé / le plus bas. Le profit est défini en fonction du rapport risque / récompense. Cela peut bloquer les profits dans une certaine mesure et contrôler les risques.

Analyse des avantages

Le plus grand avantage de cette stratégie est sa forte capacité à identifier les points d'inversion de tendance. Lorsque les prix forment un certain nombre de canaux internes, cela indique souvent qu'un mouvement de hausse/baisse relativement important est sur le point de se produire. Ce jugement est très conforme aux théories traditionnelles de l'analyse technique.

En outre, la configuration de la stratégie elle-même est très forte. Les utilisateurs peuvent librement sélectionner des paramètres tels que le nombre de canaux internes, le cycle de moyenne mobile, la méthode stop loss / take profit, etc. Cela offre une grande flexibilité pour différents produits et styles de trading.

Enfin, le filtre de moyenne mobile et les paramètres stop-loss/take-profit introduits dans la stratégie réduisent également considérablement les risques commerciaux.

Analyse des risques

Le plus grand risque de cette stratégie est la probabilité relativement élevée de jugements de tendance incorrects. Les canaux internes ne peuvent pas déterminer complètement les renversements de prix, il y a une certaine probabilité de mauvais jugement. Si la quantité déterminée est insuffisante, de faux signaux peuvent se produire.

En outre, la stratégie est complètement inutile dans les marchés latéraux ou volatils. Lorsque les prix fluctuent à la hausse et à la baisse sans établir une tendance, la stratégie générera continuellement des signaux incorrects. Cela est déterminé par le mécanisme de la stratégie.

Enfin, si le stop loss est réglé trop prudemment, la stratégie peut ne pas être en mesure de maintenir des positions assez longtemps pour capturer des bénéfices dans les tendances majeures.

Directions d'optimisation

L'espace d'optimisation de cette stratégie est encore assez large.

Optimiser la quantité et les modèles des canaux internes. Tester les effets commerciaux sous différentes quantités ou différents arrangements de combinaison.
Optimiser le paramètre de cycle de la moyenne mobile pour mieux déterminer la direction de la tendance.
Ajoutez d'autres filtres d'indicateur. Par exemple, introduisez des bandes de Bollinger et ne générez des signaux de trading que lorsque les prix franchissent les rails supérieurs ou inférieurs des bandes.
Optimiser les paramètres stop loss/take profit pour permettre à la stratégie de maintenir des positions plus longtemps.

En général, l'existence de cette stratégie réside dans l'exactitude de son jugement sur la tendance.

Conclusion

En résumé, cette stratégie est une stratégie de trading quantitative qui détermine les tendances futures des prix basées sur les canaux de prix internes. Elle combine les méthodes de jugement de suivi de tendance et d'inversion de tendance et présente certains avantages. Mais il y a aussi une marge d'optimisation pour répondre à des produits et des environnements de trading spécifiques. Après l'optimisation des paramètres, elle peut devenir l'une des stratégies de trading quantitative les plus idéales.

/*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)

Plus de

2019 FMZ - Tous les droits réservés