Koordinierte Strategie für einen gleitenden Stop-Loss

Schriftsteller:ChaoZhang, Datum: 2023-11-02 16:28:55
Tags:

Übersicht

Diese Strategie verwendet den stochastischen RSI und den Preisänderungsindikator, um die Trendrichtung für den Einstieg zu identifizieren und den gleitenden Stop-Loss für das Risikomanagement zu koordinieren.

Strategie Logik

Erstens berechnet die Strategie den Stochastischen RSI mit dem RSI-Indikator mit Länge 5 und dem Stochastischen Indikator mit Länge 7. Wenn der Stochastische RSI-K-Wert über dem D-Wert liegt, ist es ein Aufwärtssignal. Wenn K unter D liegt, ist es ein Bärensignal.

Zweitens berechnet die Strategie den Kursänderungsindikator EMA ROC. Wenn der EMA ROC über der Schwellenhälfte oder unter der negativen Schwellenhälfte liegt, wird eine aktive Preisbewegung ermittelt.

Wenn der Stochastic RSI bullisch ist und sich der Preis aktiv bewegt, geht man lang. Wenn der Stochastic RSI bärisch und sich der Preis aktiv bewegt, geht man kurz.

Schließlich verwendet die Strategie für das Risikomanagement einen koordinierten, gleitenden Stop-Loss. Nach der Eröffnung einer Position wird der höchste/niedrigste Preis weiter aktualisiert und ein bestimmter Prozentsatz des Abstands vom höchsten/niedrigsten Preis als Stop-Loss-Level verwendet.

Analyse der Vorteile

Die Vorteile dieser Strategie:

Der stochastische RSI-Indikator identifiziert effektiv Trends und Überkauf/Überverkaufssituationen.
Der Kurswechsel filtert den Markt aus dem Bereich, um falsche Signale zu vermeiden.
Koordinierte Sliding Stop Loss können Gewinne in größtmöglichem Umfang sichern und gleichzeitig das Risiko kontrollieren.
Die Strategie bietet einen großen Optimierungsraum für Parameter, die auf verschiedenen Produkten basieren.
Die Strategielogik ist einfach und klar, leicht verständlich und umsetzbar.

Risikoanalyse

Die Risiken dieser Strategie:

Der stochastische RSI kann falsche Signale erzeugen und muss mit anderen Faktoren bestätigt werden.
Coordinate Sliding Stop Loss kann zu aggressiv sein, kann über Nacht durch Lücken gestoppt werden.
Kurzfristige Umkehrungen können zum Stop-Loss führen.
Die Parameter müssen für verschiedene Produkte optimiert werden, sonst kann die Leistung schlecht sein.
Die Handelskosten beeinflussen die Rentabilität der Strategie, eine angemessene Handelsfrequenz ist erforderlich.

Optimierungsrichtlinien

Die Strategie kann in folgenden Bereichen weiter optimiert werden:

Optimieren Sie die Stochastischen RSI-Parameter, um falsche Signale zu reduzieren.
Optimieren Sie die Preisrate der Parameteränderung, um den Filterungseffekt zu verbessern.
Fügen Sie einen Trendindikator hinzu, damit Sie nicht von Umkehrungen wie gleitenden Durchschnitten abgehalten werden.
Optimieren Sie den Stop-Loss-Prozentsatz, um das Risiko zu verringern, dass Sie eingeschlossen werden.
Hinzufügen von Positionsgrößenverwaltung zur Steuerung von Einzelhandelsrisiken, z. B. festes Stop-Loss-Betrag oder dynamische Anpassung der Positionsgröße anhand des Kontokapitals.
Testparameter auf verschiedenen Produkten zur Verbesserung der Anpassungsfähigkeit.

Zusammenfassung

Zusammenfassend lässt sich sagen, dass diese Strategie eine klare und einfache Logik aufweist, die Trendrichtung mit dem stochastischen RSI identifiziert und Signale mit der Kursänderung filtert, die mittelfristige und langfristige Trends effektiv erfassen können.

/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Sto2", 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(2017, "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
    
///////////// Stochastic calc /////////////
smoothK = input(1, minval=1)
smoothD = input(7, minval=1)
lengthRSI = input(5, minval=1)
lengthStoch = input(7, minval=1)
src = input(close, title="RSI Source")

up = sma(max(change(src), 0), lengthRSI) 
down = sma(-min(change(src), 0), lengthRSI)
rsi1 = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))

k = sma(stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = sma(k, smoothD)

///////////// Rate Of Change ///////////// 
source = close, roclength = input(14, minval=1), pcntChange = input(2, 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 = k > d and isMoving()
short = k < d 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(2.0, title='Stop Loss %') / 100
tp_inp = input(9.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]) // LONG SL
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) // SHORT SL

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

// Strategy
if testPeriod()
    strategy.entry("Long Entry",  strategy.long, when=long)
    strategy.entry("Short Entry", strategy.short, when=short)
    strategy.exit("Long Ex", "Long Entry", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("Short Ex", "Short Entry", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
    
///////////// Plotting /////////////
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
p1 = plot(k, color=color.gray, linewidth=0)
p2 = plot(d, color=color.gray, linewidth=0)
h0 = hline(100)
h1 = hline(50)
h3 = hline(0)
fill(p1, p2, color = k > d ? color.lime : color.red, transp=70)

Mehr