Une stratégie de négociation de renversement de l'indice de risque

Auteur:ChaoZhang est là., Date: 2024-01-30 17h06h45
Les étiquettes:

Résumé

Cette stratégie identifie les conditions de marché de surachat et de survente à l'aide de l'indicateur RSI pour passer à court sur les croisements baissiers dans les zones de surachat et à long sur les croisements haussiers dans les zones de survente.

La logique de la stratégie

Les signaux de trading de cette stratégie sont générés sur la base des croisements haussier/baissier de l'indicateur RSI. L'indicateur RSI utilise généralement 30 comme ligne de survente et 70 comme ligne de surachat. Lorsque la ligne RSI traverse au-dessus de la ligne de survente, un signal d'achat est généré. Lorsque la ligne RSI traverse en dessous de la ligne de surachat, un signal de vente est généré. Sur la base de cette logique, la stratégie identifie les zones de surachat et de survente et génère les signaux longs/courts correspondants.

Après avoir entré dans une position, la stratégie utilise des arrêts de suivi en pourcentage en actualisant continuellement le prix le plus élevé / le plus bas atteint et en suivant un pourcentage fixe en dehors de celui-ci comme stop-loss.

Analyse des avantages

Les avantages de cette stratégie sont les suivants:

L'utilisation de l'indicateur de volatilité pour identifier les niveaux de surachat/survente est une technique de négociation mature permettant de détecter de manière fiable les points tournants du marché.
L'utilisation de croisements haussier/baissier filtre certains faux signaux et rend le trading plus fiable.
Les arrêts de suivi de tendance bloquent les bénéfices autant que possible, tout en ayant des arrêts rapides pour contenir les pertes par transaction.
Les niveaux fixes de TP/SL contrôlent également efficacement le risque par transaction.
Logique générale simple et claire, facile à comprendre et à mettre en œuvre, adaptée aux débutants.

Analyse des risques

Les risques de cette stratégie comprennent:

Les signaux RSI peuvent être faux, avec une forte probabilité d'échec du modèle, entraînant un déclenchement de stop loss.
Le TP/SL fixe ne peut pas s'adapter à la volatilité du marché, peut réduire les bénéfices ou laisser des pertes.
Le pourcentage de suivi ne suit que le prix le plus élevé/le plus bas, peut être trop agressif, laissant les bénéfices derrière.
Le risque de suradaptation en tant que paramètres pourrait être optimisé pour les données historiques.
La fréquence des échanges est élevée, ce qui augmente les coûts de transaction et les dérapages.

Directions d'optimisation

Des moyens possibles d'améliorer la stratégie:

Optimiser les paramètres de l'indicateur RSI pour obtenir les meilleurs résultats.
Ajouter des indicateurs de filtre pour une plus grande précision du signal.
Des arrêts/profits adaptatifs basés sur la volatilité du marché.
Limitez la fréquence des échanges pour réduire les coûts de transaction.
Ajouter la taille des positions pour limiter les pertes par transaction.
Test de retour sur une période plus longue pour tester la stabilité.

Conclusion

En résumé, il s'agit d'une stratégie d'inversion typique utilisant le RSI pour identifier le surachat/survente, avec des croisements taureau/ours comme signaux.

/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// LOVE JOY PEACE PATIENCE KINDNESS GOODNESS FAITHFULNESS GENTLENESS SELF-CONTROL 
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// Author: © JoshuaMcGowan
// Taken from https://www.tradingview.com/script/GbZGYi6l-Adding-some-essential-components-to-a-prebuilt-RSI-strategy/
// Just updated to compile in version 4. 

//@version=4

strategy("Adding some essential components to a prebuilt RSI strategy", overlay=true)

/////////////// Component Code Start ///////////////

testStartYear = input(2011, "Backtest Start Year") 
testStartMonth = input(8, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2100, "Backtest Stop Year")
testStopMonth = input(9, "Backtest Stop Month")
testStopDay = input(29, "Backtest Stop Day")
// testStopDay = testStartDay + 1
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=input.bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
    
/////////////// Component Code Stop ///////////////

// Replace RSI Component, Long/Short, and Long Signal/Short Signal conditions with your trade setup components.
///////////// RSI component /////////////

length = input( 14 )
overSold = input( 30 )
overBought = input( 70 )
price = close

vrsi = rsi(price, length)
notna = not na(vrsi)

/////////////// STRATEGY ///////////////

ts = input(99999, "Trailing Stop") / 100
tp = input(99999, "Take Profit") / 100
sl = input(99999, "Stop Loss") / 100

// Update this with your setup. 
long = notna and crossover(vrsi, overSold)
short = notna and crossunder(vrsi, overBought)

last_long = 0
last_short = 0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

// Update this to reflect your setup. 
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

float last_open_long_signal = 0
float last_open_short_signal = 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
last_short_signal = 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

float last_high = 0
float last_low = 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])

long_ts = not na(last_high) and high <= (last_high - ts) //and high >= last_open_long_signal
short_ts = not na(last_low) and low >= (last_low + ts) //and low <= last_open_short_signal

long_tp = high >= (last_open_long_signal + tp)
short_tp = low <= (last_open_short_signal - tp)

long_sl = low <= (last_open_long_signal - sl)
short_sl = high >= (last_open_short_signal + sl)

leverage = input(200, "Leverage")
long_call = last_open_long_signal - (0.8 + 0.2 * (1/leverage)) / leverage * last_open_long_signal
short_call = last_open_short_signal + (0.78 + 0.2 * (1/leverage)) / leverage * last_open_short_signal
long_call_signal = low <= long_call
short_call_signal = high >= short_call

if testPeriod()
    strategy.entry("Long", strategy.long, when=long_signal)
    strategy.entry("Short", strategy.short, when=short_signal)

    // plot(long_call, color=color.red)
    // plot(short_call, color=color.green)
    strategy.close("Long", when=long_call_signal)
    strategy.close("Short", when=short_call_signal)
    strategy.close("Long", when=long_tp)
    strategy.close("Short", when=short_tp)
    strategy.close("Long", when=long_sl)
    strategy.close("Short", when=short_sl)
    strategy.close("Long", when=long_ts)
    strategy.close("Short", when=short_ts)

Plus de

2019 FMZ - Tous les droits réservés