Die Ressourcen sind geladen. Beförderung...

Wahrscheinlichkeitsstärkte RSI-Strategie

Schriftsteller:ChaoZhang, Datum: 20.12.2023
Tags:

Übersicht

Dies ist eine einfache Long-Only-Strategie, bei der der RSI-Indikator verwendet wird, um Überkauf- und Überverkaufsniveaus zu bestimmen. Wir haben sie durch Hinzufügen von Stop-Loss und Take-Profit verbessert und ein Wahrscheinlichkeitsmodul in den Verstärkungshandel integriert, nur wenn die kürzliche profitable Handelswahrscheinlichkeit größer oder gleich 51% ist. Dies verbesserte die Strategieleistung erheblich, indem potenzielle Verlustgeschäfte vermieden wurden.

Grundsätze

Die Strategie verwendet den RSI-Indikator, um die Marktüberkauf- und Überverkaufszustände zu beurteilen. Insbesondere geht es lang, wenn der RSI unter die untere Grenze der Überverkaufszone fällt; und schließt die Position, wenn der RSI über die obere Grenze der Überkaufszone fällt. Darüber hinaus setzen wir Stop-Loss- und Take-Profit-Verhältnisse.

Der Schlüssel ist, dass wir ein Wahrscheinlichkeitsbeurteilungsmodul integriert haben. Dieses Modul berechnet den profitablen Prozentsatz der langen Trades in den letzten Perioden (definiert durch Lookback-Parameter). Es erlaubt nur den Eintrag, wenn die kürzlich profitable Handelswahrscheinlichkeit größer oder gleich 51% ist. Dies vermeidet viele potenzielle Verliertrades.

Vorteile

Als eine RSI-Strategie mit erhöhtem Wahrscheinlichkeitsgrad hat sie im Vergleich zu einfachen RSI-Strategien folgende Vorteile:

Zusätzliche Stop-Loss- und Take-Profit-Kontrollen Einzelhandelsverluste und Gewinnabsperrungen
Integriertes Wahrscheinlichkeitsmodul vermeidet Märkte mit geringer Wahrscheinlichkeit
Das Wahrscheinlichkeitsmodul kann für verschiedene Marktumgebungen angepasst werden
Der langfristige Mechanismus ist einfach zu verstehen und umzusetzen

Risikoanalyse

Diese Strategie birgt noch einige Risiken:

Nur langfristig, nicht in der Lage, von dem fallenden Markt zu profitieren
Eine falsche Beurteilung des Wahrscheinlichkeitsmoduls könnte Chancen verpassen
Schwierig, die beste Parameterkombination zu finden, erhebliche Leistungsunterschiede zwischen den Marktumgebungen
Lose Stop-Loss-Einstellung, immer noch möglich großer Einzelverlust

Lösungen:

Überlegen Sie, einen kurzen Mechanismus hinzuzufügen
Optimierung des Wahrscheinlichkeitsmoduls zur Verringerung der Fehlerquote
Maschinelles Lernen zur dynamischen Optimierung von Parametern
Festlegen eines konservativeren Stop-Loss-Niveaus zur Begrenzung des Verlusts

Anweisungen zur Verbesserung

Die Strategie könnte in folgenden Bereichen weiter optimiert werden:

Erhöhung des Kurzmoduls für den Doppelrichtungshandel
Verwenden Sie maschinelles Lernen für dynamische Parameteroptimierung
Versuchen Sie andere Indikatoren für Überkauf/Überverkauf
Optimierung von Stop-Loss/Take-Profit zur Steigerung der Gewinnquote
Hinzufügen anderer Faktoren, um Signale zu filtern und die Wahrscheinlichkeit zu verbessern

Zusammenfassung

Dies ist eine einfache RSI-Strategie, die durch ein integriertes Wahrscheinlichkeitsmodul erweitert wird. Im Vergleich zu Vanille-RSI-Strategien filtert sie einige verlorene Trades aus und verbessert die Gesamtverzinsung und das Gewinnverhältnis. Der nächste Schritt könnte sein, sie zu verbessern, indem sie kurze, dynamische Optimierung usw. hinzufügt, um sie robuster zu machen.

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

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © thequantscience

//@version=5
strategy("Reinforced RSI",
     overlay = true,
     default_qty_type = strategy.percent_of_equity, 
     default_qty_value = 100,
     pyramiding = 1,
     currency = currency.EUR, 
     initial_capital = 1000,
     commission_type = strategy.commission.percent, 
     commission_value = 0.07)

lenght_rsi = input.int(defval = 14, minval = 1, title = "RSI lenght: ")
rsi = ta.rsi(close, length = lenght_rsi)

rsi_value_check_entry = input.int(defval = 35, minval = 1, title = "Oversold: ")
rsi_value_check_exit = input.int(defval = 75, minval = 1, title = "Overbought: ")

trigger = ta.crossunder(rsi, rsi_value_check_entry)
exit = ta.crossover(rsi, rsi_value_check_exit)

entry_condition   = trigger 
TPcondition_exit  = exit

look = input.int(defval = 30, minval = 0, maxval = 500, title = "Lookback period: ")

Probabilities(lookback) =>

    isActiveLong = false
    isActiveLong := nz(isActiveLong[1], false)
    isSellLong = false
    isSellLong := nz(isSellLong[1], false)

    int positive_results = 0
    int negative_results = 0

    float positive_percentage_probabilities = 0 
    float negative_percentage_probabilities = 0 

    LONG = not isActiveLong and entry_condition == true 
    CLOSE_LONG_TP = not isSellLong and TPcondition_exit == true

    p = ta.valuewhen(LONG, close, 0)
    p2 = ta.valuewhen(CLOSE_LONG_TP, close, 0)

    for i = 1 to lookback

	    if (LONG[i])
            isActiveLong := true
		    isSellLong := false

        if (CLOSE_LONG_TP[i])
	        isActiveLong := false
	        isSellLong := true

        if p[i] > p2[i]
            positive_results += 1
        else 
            negative_results -= 1 

	    positive_relative_probabilities = positive_results / lookback
	    negative_relative_probabilities = negative_results / lookback
	    positive_percentage_probabilities := positive_relative_probabilities * 100
	    negative_percentage_probabilities := negative_relative_probabilities * 100

    positive_percentage_probabilities
	
probabilities = Probabilities(look) 

lots = strategy.equity/close

var float e = 0 
var float c = 0 

tp = input.float(defval = 1.00, minval = 0, title = "Take profit: ")
sl = input.float(defval = 1.00, minval = 0, title = "Stop loss: ")

if trigger==true and strategy.opentrades==0 and probabilities >= 51
    e := close
    strategy.entry(id = "e", direction = strategy.long, qty = lots, limit = e) 
takeprofit = e + ((e * tp)/100)
stoploss = e - ((e * sl)/100)
if exit==true
    c := close 
    strategy.exit(id = "c", from_entry = "e", limit = c)
if takeprofit and stoploss 
    strategy.exit(id = "c", from_entry = "e", stop = stoploss, limit = takeprofit)

Mehr