Stratégie longue et courte avec indicateur RSI
ChaoZhang
Aperçu
Cette stratégie est basée sur l’indicateur de force relative (RSI) et est considérée comme une stratégie de trading RSI typique. La stratégie a des fonctions d’optimisation des paramètres, de stop loss et d’adaptation des paramètres aux différentes conditions du marché.
Principe de stratégie
La logique centrale de la stratégie est la suivante:
- Calculer le RSI
- Définition de la limite supérieure et inférieure du RSI
- Le RSI est à la limite de l’entrée.
- L’indice de résistance à la hausse (RSI) est un indicateur de la hausse de l’activité.
- Définition des conditions d’arrêt
- Le RSI est à plat quand il rentre dans la fourchette ou quand il déclenche une condition de stop loss
L’indicateur RSI peut indiquer si le marché est en survente ou en survente. Il est considéré comme étant en survente lorsque le RSI est supérieur à 70 et en survente lorsque le RSI est inférieur à 30. La stratégie de négociation consiste à déterminer s’il convient d’établir une position vide ou une position à plusieurs positions en fonction de la survente ou de la survente du RSI.
Cette stratégie utilise la logique classique de l’indicateur RSI pour déterminer la direction de la position en fonction de la relation entre la valeur du RSI et la limite supérieure et inférieure prédéfinie. En outre, la stratégie dispose de paramètres ajustables qui permettent d’optimiser la limite supérieure et inférieure du RSI, la marge de stop-loss, etc., afin de s’adapter aux changements du marché.
Avantages stratégiques
- L’indicateur RSI peut être utilisé pour évaluer efficacement les conditions de survente du marché
- La théorie de l’indicateur RSI est largement acceptée
- Les paramètres de la stratégie peuvent être ajustés pour s’adapter à différentes variétés et conditions de marché
- Un système intégré d’arrêt de perte pour contrôler les risques
Risques stratégiques et réponse
- Le RSI pourrait émettre de faux signaux, entraînant des pertes inutiles
- La nécessité d’optimiser continuellement la plage de paramètres RSI
- La perturbation peut être déclenchée par Frequent.
Contre-mesures :
- Confirmation multifactorielle combinée à d’autres indicateurs pour éviter les faux signaux
- Optimisation de la plage de paramètres RSI en fonction des caractéristiques des différentes variétés
- Ajustez la position de stop pour réduire le risque de prise de risque
Orientation de l’optimisation de la stratégie
Cette stratégie peut être étendue et optimisée dans les domaines suivants:
Optimisation automatique de la plage de paramètres RSI par apprentissage automatique
Augmenter le nombre de confirmations de transactions et éviter les fausses percées
Vérification multifactorielle combinée à des indicateurs tels que la moyenne mobile
Mettre en place une stratégie de stop-loss adaptative, en ajustant le stop-loss en fonction des fluctuations du marché
En étudiant les variations du volume des transactions, il est possible d’évaluer les entrées et sorties de fonds.
Combinaison avec d’autres stratégies non pertinentes pour réduire le retrait global
Résumer
La stratégie utilise le RSI pour juger de la survente et de la survente. C’est une stratégie de retournement simple et pratique. La stratégie peut être ajustée en fonction des paramètres des changements de marché, mais peut également être étendue et optimisée en plusieurs dimensions.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-18 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("4All V3", shorttitle="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(2018, "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=bool, defval=true)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
/////////////// Component Code Stop ///////////////
src = close
len = input(4, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsin = input(5)
sn = 100 - rsin
ln = 0 + rsin
/////////////// STRATEGY ///////////////
ts = input(99999, "Trailing Stop") / 10000
tp = input(15, "Take Profit") / 10000
sl = input(23, "Stop Loss") / 10000
pyr = input(1, "Pyramiding")
short = crossover(rsi, sn)
long = crossunder(rsi, ln)
totalLongs = 0
totalLongs := nz(totalLongs[1])
totalShorts = 0
totalShorts := nz(totalShorts[1])
totalLongsPrice = 0
totalLongsPrice := nz(totalLongsPrice[1])
totalShortsPrice = 0
totalShortsPrice := nz(totalShortsPrice[1])
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
longCondition = long and sectionLongs >= pyr
shortCondition = short and sectionShorts >= pyr
last_long = na
last_short = na
last_long := longCondition ? time : nz(last_long[1])
last_short := shortCondition ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = na
last_open_short_signal = na
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 = na
last_short_signal = na
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 = na
last_low = na
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(1, "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=longCondition)
strategy.entry("Short", strategy.short, when=shortCondition)
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)