Stratégie de trading de régression RSI à plusieurs niveaux et ajustement dynamique de la volatilité
RSI、PIVOT
ChaoZhang
Aperçu
Cette stratégie est un système de négociation de retournement de la moyenne à plusieurs niveaux basé sur l’indicateur RSI et la volatilité des prix. Elle utilise les valeurs extrêmes du RSI et les fluctuations anormalement importantes des prix comme signaux d’entrée, tout en utilisant des surtensions pyramidales et des arrêts dynamiques pour gérer les risques et optimiser les rendements. L’idée centrale de cette stratégie est d’entrer en position lorsque le marché est en situation d’extrême volatilité et de tirer profit lorsque les prix reviennent à des niveaux normaux.
Principe de stratégie
Conditions d’entrée :
- Le RSI à 20 cycles (RSI20) est utilisé comme indicateur principal.
- Définir plusieurs seuils RSI ((35⁄65, 30⁄70, 25⁄75, 20⁄80) et les seuils de taux de fluctuation correspondants
- Un signal d’entrée est déclenché lorsque le RSI atteint un certain seuil et que la taille de l’entité de ligne K actuelle dépasse le seuil de fluctuation correspondant
- Condition supplémentaire: le prix doit franchir un certain pourcentage du support du haut/bas le plus récent
Le mécanisme d’accélération:
- Maximum de 5 entrées (entrée initiale + 4 entrées supplémentaires)
- Chaque prise de position doit répondre à des conditions de RSI et de volatilité plus strictes
Le mécanisme de sortie:
- 5 niveaux de points d’arrêt différents
- Le point d’arrêt est calculé sur la base de la dynamique de support/résistance au moment de l’entrée.
- Les objectifs de couverture sont réduits à mesure que le nombre de positions augmente.
Contrôle des risques:
- Utilisation d’un modèle de risque par pourcentage, le risque est fixé à 20% du total du compte pour chaque transaction
- Réglage du nombre maximal de positions simultanées à 5 pour limiter l’ouverture de risque globale
Avantages stratégiques
Entrée à plusieurs niveaux: en définissant plusieurs RSI et seuils de volatilité, la stratégie peut capturer différents niveaux d’extrême du marché et améliorer les opportunités de négociation.
Stop-loss dynamique: Stop-loss basé sur le support/résistance, qui s’adapte à la structure du marché, protégeant ainsi les bénéfices et empêchant la sortie prématurée.
La pyramide de prise de position: augmenter le portefeuille pendant que la tendance se poursuit peut augmenter considérablement le potentiel de profit.
Gestion des risques: pourcentage de risque fixe et limite de placement maximale, pour un contrôle efficace du risque par transaction et le risque global.
Flexibilité: un grand nombre de paramètres réglables permettent à la stratégie de s’adapter à différents environnements de marché et types de transactions.
Rétroaction moyenne + suivi des tendances: combinant les avantages de la rétrogradation moyenne et du suivi des tendances, il permet de capturer les retournements à court terme sans perdre de vue les grandes tendances.
Risque stratégique
Surtravail: Les signaux de trading peuvent être déclenchés fréquemment dans des marchés très volatils, ce qui entraîne des frais de traitement excessifs.
Fausse rupture: le marché peut se redresser rapidement après une brève fluctuation extrême, provoquant de faux signaux.
Perte continue: Si le marché continue à se déplacer dans une seule direction, cela peut entraîner de lourdes pertes après plusieurs prises de position.
Sensitivité des paramètres: les performances de la stratégie peuvent être très sensibles aux paramètres, avec un risque de suradaptation.
Effets des points de glissement: pendant les périodes de forte volatilité, il peut y avoir des points de glissement importants qui affectent la performance de la stratégie.
Dépendance des conditions du marché: la stratégie peut être défectueuse dans certaines conditions du marché, comme une faible volatilité ou une forte tendance.
Orientation de l’optimisation de la stratégie
Adaptation des paramètres dynamiques: un mécanisme d’adaptation est introduit pour ajuster dynamiquement le RSI et les marges de volatilité en fonction de l’état du marché.
Analyse des cycles de temps multiples: une meilleure qualité d’entrée, combinée à une meilleure compréhension des tendances du marché à plus long terme.
Optimisation des arrêts de perte: augmentation des arrêts de suivi ou des arrêts de perte dynamiques basés sur l’ATR, afin de mieux contrôler les risques.
Filtrage de l’état du marché: ajouter des conditions de filtrage telles que l’intensité de la tendance et la période de volatilité pour éviter de négocier dans un environnement de marché inapproprié.
Optimisation de la gestion des fonds: réalisation d’une gestion plus minutieuse des positions, par exemple en ajustant la taille des transactions en fonction des différents niveaux de signaux.
Intégration de l’apprentissage automatique: optimisation du processus de sélection des paramètres et de génération de signaux à l’aide d’algorithmes d’apprentissage automatique.
L’analyse de la corrélation: ajoutée à l’analyse de la corrélation avec d’autres actifs pour améliorer la stabilité et la diversité de la stratégie.
Résumer
La stratégie de trading de régression RSI à plusieurs niveaux est un système de trading quantitatif soigneusement conçu, qui combine habilement l’analyse technique, la gestion dynamique des risques et les techniques de prise de position pyramidale. La stratégie présente un fort potentiel de profit en capturant les fluctuations extrêmes du marché et en profitant des retours de prix. Cependant, elle est également confrontée à des défis tels que l’excès de trading et la dépendance aux conditions du marché.
/*backtest
start: 2024-05-01 00:00:00
end: 2024-05-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy('Retorno_Pivots_5min_Novo_v3.3')
// Input variables
bars_left1 = input(1, title = "Entry - Pivot Left Bars")
bars_right1 = input(1, title = "Entry - Pivot Right Bars")
rsi20_longentry0 = input(35, title = "Entry 1 - RSI20 Long")
rsi20_shortentry0 = input(65, title = "Entry 1 - RSI20 Short")
bar_size_entry0 = input.float(1, title="Entry 1 - Bar Size")
rsi20_longentry1 = input(30, title = "Entry 2 - RSI20 Long")
rsi20_shortentry1 = input(70, title = "Entry 2 - RSI20 Short")
bar_size_entry1 = input.float(0.8, title="Entry 2 - Bar Size")
rsi20_longentry2 = input(25, title = "Entry 3 - RSI20 Long")
rsi20_shortentry2 = input(75, title = "Entry 3 - RSI20 Short")
bar_size_entry2 = input.float(0.7, title="Entry 3 - Bar Size")
rsi20_longentry3 = input(20, title = "Entry 4 - RSI20 Long")
rsi20_shortentry3 = input(80, title = "Entry 4 - RSI20 Short")
bar_size_entry3 = input.float(0.5, title="Entry 4 - Bar Size")
limit_perc1 = input.float(0.60, title="Profit Range 1")
limit_perc2 = input.float(0.40, title="Profit Range 2")
limit_perc3 = input.float(0.20, title="Profit Range 3")
limit_perc4 = input.float(0.00, title="Profit Range 4")
limit_perc5 = input.float(0.00, title="Profit Range 5")
minimum_pivot_distance = input.float(0, title="Minimum Pivot Distance %")
barsize_1h_input = input(288, title="Highest Bar Lookback")
rsi20 = ta.rsi(close, 20)
rsi200 = ta.rsi(close, 200)
Pivot_High_Last1 = ta.valuewhen(ta.pivothigh(high, bars_left1, bars_right1), ta.pivothigh(high, bars_left1, bars_right1), 0)
Pivot_Low_Last1 = ta.valuewhen(ta.pivotlow(low, bars_left1, bars_right1), ta.pivotlow(low, bars_left1, bars_right1), 0)
barsize = math.abs(close - open)
barsize_1h = ta.highest(barsize, barsize_1h_input)
Bar0Long = rsi20 < rsi20_longentry0 and barsize >= (barsize_1h * bar_size_entry0)
Bar1Long = rsi20 < rsi20_longentry1 and barsize >= (barsize_1h * bar_size_entry1)
Bar2Long = rsi20 < rsi20_longentry2 and barsize >= (barsize_1h * bar_size_entry2)
Bar3Long = rsi20 < rsi20_longentry3 and barsize >= (barsize_1h * bar_size_entry3)
// Long Entries
Long_Entry1 = strategy.opentrades == 0 and rsi20 < rsi20[1] and ((rsi20 < rsi20_longentry0 and barsize >= (barsize_1h * bar_size_entry0)) or (rsi20 < rsi20_longentry1 and barsize >= (barsize_1h * bar_size_entry1)) or (rsi20 < rsi20_longentry2 and barsize >= (barsize_1h * bar_size_entry2)) or (rsi20 < rsi20_longentry3 and barsize >= (barsize_1h * bar_size_entry3))) and close < (Pivot_Low_Last1 * (1 - (minimum_pivot_distance / 100)))
Long_Entry2 = strategy.opentrades == 1 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry3 = strategy.opentrades == 2 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry4 = strategy.opentrades == 3 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
Long_Entry5 = strategy.opentrades == 4 and strategy.position_size > 0 and rsi20 < rsi20[1] and (Bar0Long or Bar1Long or Bar2Long or Bar3Long)
if Long_Entry1 or Long_Entry2 or Long_Entry3 or Long_Entry4 or Long_Entry5
strategy.entry("Long", strategy.long, comment = "ENTER-LONG_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
// Longs Exits
Long_Exit1 = strategy.opentrades == 1 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc1))
Long_Exit2 = strategy.opentrades == 2 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc2))
Long_Exit3 = strategy.opentrades == 3 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc3))
Long_Exit4 = strategy.opentrades == 4 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc4))
Long_Exit5 = strategy.opentrades == 5 and close > (strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc5))
if Long_Exit1 or Long_Exit2 or Long_Exit3 or Long_Exit4 or Long_Exit5
strategy.close("Long", comment = "EXIT-LONG_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
Bar0Short = rsi20 > rsi20_shortentry0 and barsize >= (barsize_1h * bar_size_entry0)
Bar1Short = rsi20 > rsi20_shortentry1 and barsize >= (barsize_1h * bar_size_entry1)
Bar2Short = rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2)
Bar3Short = rsi20 > rsi20_shortentry3 and barsize >= (barsize_1h * bar_size_entry3)
// Short Entries
Short_Entry1 = strategy.opentrades == 0 and rsi20 > rsi20[1] and ((rsi20 > rsi20_shortentry0 and barsize >= (barsize_1h * bar_size_entry0)) or (rsi20 > rsi20_shortentry1 and barsize >= (barsize_1h * bar_size_entry1)) or (rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2)) or (rsi20 > rsi20_shortentry2 and barsize >= (barsize_1h * bar_size_entry2))) and close > (Pivot_High_Last1 * (1 + (minimum_pivot_distance / 100)))
Short_Entry2 = strategy.opentrades == 1 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry3 = strategy.opentrades == 2 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry4 = strategy.opentrades == 3 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
Short_Entry5 = strategy.opentrades == 4 and strategy.position_size < 0 and rsi20 > rsi20[1] and (Bar0Short or Bar1Short or Bar2Short or Bar3Short)
if Short_Entry1 or Short_Entry2 or Short_Entry3 or Short_Entry4 or Short_Entry5
strategy.entry("Short", strategy.short, comment = "ENTER-SHORT_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
// Short Exits
Short_Exit1 = strategy.opentrades == 1 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc1))
Short_Exit2 = strategy.opentrades == 2 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc2))
Short_Exit3 = strategy.opentrades == 3 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc3))
Short_Exit4 = strategy.opentrades == 4 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc4))
Short_Exit5 = strategy.opentrades == 5 and close < (strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc5))
if Short_Exit1 or Short_Exit2 or Short_Exit3 or Short_Exit4 or Short_Exit5
strategy.close("Short", comment = "EXIT-SHORT_BINANCE-FUTURES_BTCBUSD_Bot-BTC-1min_1M_970d2ee265390c27")
// Plots
plot(rsi20, color=color.new(#fbff00, 0), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc1))), color=color.new(#00ff2a, 0), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc2))), color=color.new(#00ff2a, 50), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc3))), color=color.new(#00ff2a, 80), linewidth=2)
plot(((strategy.position_avg_price + ((ta.valuewhen(strategy.opentrades == 0, Pivot_Low_Last1, 0) - (strategy.position_avg_price)) * limit_perc4))), color=color.new(#00ff2a, 100), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc1)), color=color.new(#ff0000, 0), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc2)), color=color.new(#ff0000, 50), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc3)), color=color.new(#ff0000, 80), linewidth=2)
plot((strategy.position_avg_price - ((strategy.position_avg_price - ta.valuewhen(strategy.opentrades == 0, Pivot_High_Last1, 0)) * limit_perc4)), color=color.new(#ff0000, 100), linewidth=2)
plot(strategy.position_avg_price, color=color.new(#ffc400, 0), linewidth=2)
plot(strategy.opentrades * (strategy.position_size / math.abs(strategy.position_size)), color=color.new(#ff00bb, 0), linewidth=2)
plot(((barsize / barsize_1h) * 100), color=color.new(#0000ff, 0), linewidth=2)