Stratégie de retournement à double voie
ChaoZhang
Aperçu
Une stratégie de revers de suivi à deux voies est une stratégie de revers de négociation qui combine les bandes de Brin, les canaux de Keltner et les indicateurs de dynamique. La stratégie identifie le moment où le prix entre dans la zone de compression en utilisant un jugement global des bandes de Brin et des canaux de Keltner.
Principe de stratégie
Calculer la voie moyenne, la voie supérieure et la voie inférieure dans la bande de Brin
- La voie médiane adopte le SMA de close
- La trajectoire ascendante et descendante est la différence standard entre la trajectoire moyenne et un multiple ajustable
Calculer la voie moyenne, la voie supérieure et la voie inférieure dans le canal de Keltner
- La voie médiane adopte le SMA de close
- La trajectoire ascendante et descendante est l’ATR de la trajectoire moyenne plus ou moins un multiple réglable
Déterminer si la ceinture de Brin est à l’intérieur du canal Keltner
- On considère que la bande de Bryn est en compression lorsque la bande de Bryn est en orbite inférieure à la bande de Keltner et que la bande de Bryn est en orbite supérieure à la bande de Keltner.
- Au lieu de cela, ne comprimez pas.
Calculer la pente de régression linéaire de close avec le point médian de la bande de Bryn et du canal de Keltner
- val > 0 signifie que close est en hausse, val < 0 signifie que close est en baisse
Calculer le taux de variation du ROC de la clôture et son EMA
- Déterminer si le taux de variation atteint un seuil modifiable
- Si vous dépassez le seuil, vous êtes dans la tendance
En compression, faites plus lorsque val > 0 et que le taux de variation atteint une limite
- C’est plutôt faire le vide.
Définition des conditions d’arrêt et d’arrêt
Avantages stratégiques
Le système à deux voies permet une meilleure précision pour déterminer le moment de l’inversion
Augmentation de la régression linéaire et des jugements de taux de variation pour éviter les faux signaux de retournement
Paramètres réglables et flexibles, optimisés pour différentes variétés
Une stratégie de stop-loss permet de contrôler efficacement le risque de transaction unique.
Des données de suivi suffisantes pour vérifier l’efficacité de la stratégie
Risques stratégiques et solutions
La compression à deux voies ne produit pas nécessairement une inversion efficace
- Paramètres d’optimisation, conditions strictes de compression à deux voies
Une fausse intrusion génère un faux signal
- Ajout d’une régression linéaire pour déterminer la direction de la tendance
Le paramètre de stop-loss est trop lâche, les pertes sont trop importantes
- Optimisation des points de rupture et contrôle strict des pertes ponctuelles
Cycle de test Datenichinhalt
- Augmentation du nombre de cycles de reprise pour vérifier l’efficacité à long terme
Orientation de l’optimisation de la stratégie
Optimisation des paramètres pour plus de variétés
Augmenter les points de résistance à l’apprentissage automatique
Amélioration de l’authenticité de la percée combinée à l’évolution du volume des transactions
Ajout d’analyses sur plusieurs périodes pour déterminer la continuité des tendances
Optimisation des stratégies de stop loss et de suivi dynamique
Résumer
Les stratégies de rétrogradation à double traçage sont généralement des stratégies de rétrogradation utilisant des indicateurs tels que le canal de Keltner avec la ceinture de Brin. La stratégie peut être optimisée par paramètres et adaptée à différentes variétés, permettant d’identifier dans une certaine mesure la véracité de la percée.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Credit for the initial Squeeze Momentum code to LazyBear, rate of change code is from Kiasaki
strategy("Squeeze X BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)
/////////////// Time Frame ///////////////
testStartYear = input(2012, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// Squeeeeze ///////////////
length = input(20, title="BB Length")
mult = input(2.0,title="BB MultFactor")
lengthKC=input(22, title="KC Length")
multKC = input(1.5, title="KC MultFactor")
useTrueRange = input(true, title="Use TrueRange (KC)")
// Calculate BB
source = close
basis = sma(source, length)
dev = mult * stdev(source, length)
upperBB = basis + dev
lowerBB = basis - dev
// Calculate KC
ma = sma(source, lengthKC)
range = useTrueRange ? tr : (high - low)
rangema = sma(range, lengthKC)
upperKC = ma + rangema * multKC
lowerKC = ma - rangema * multKC
sqzOn = (lowerBB > lowerKC) and (upperBB < upperKC)
sqzOff = (lowerBB < lowerKC) and (upperBB > upperKC)
noSqz = (sqzOn == false) and (sqzOff == false)
val = linreg(source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)),sma(close,lengthKC)), lengthKC,0)
///////////// Rate Of Change /////////////
roclength = input(30, minval=1), pcntChange = input(7, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = val > 0 and isMoving()
short = val < 0 and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(100.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
bcolor = iff(val > 0, iff(val > nz(val[1]), color.lime, color.green), iff(val < nz(val[1]), color.red, color.maroon))
plot(val, color=bcolor, linewidth=4)
bgcolor(not isMoving() ? color.white : long ? color.lime : short ? color.red : na, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)
hline(0, color = color.white)