RSI in Kombination mit Bollinger Bands und dynamischer quantitativer Unterstützungs-/Widerstandsstrategie

Schriftsteller:ChaoZhang, Datum: 2024-01-24 15:19:22
Tags:

Übersicht

Diese Strategie verwendet den RSI-Indikator, um die überkauften/überverkauften Niveaus auf dem Markt zu beurteilen, kombiniert mit Bollinger Bands, um den Kursschwankungsbereich zu bestimmen. Darüber hinaus werden dynamische Support/Resistance basierend auf hohen/niedrigen Preisen generiert, um Kauf/Verkaufsaufträge nur dann auszulösen, wenn der Preis nahe an Support/Resistance-Niveaus liegt. Benutzer können eine Trendfilterbedingung wie einen einfachen gleitenden Durchschnitt festlegen, um sicherzustellen, dass der Preistrend mit den Handelsrichtungen übereinstimmt. Diese Strategie integriert mehrere technische Indikatoren für eine robuste Signalgenauigkeit und erfasst Marktchancen effektiv.

Strategie Logik

Die Strategie besteht aus drei Schlüsselkomponenten RSI, Bollinger Bands und Dynamic S/R.

Die RSI-Komponente beurteilt Überkauf/Überverkauft-Niveaus. Ein RSI-Absturz unter 30 deutet auf einen Überverkauf und löst ein Kaufsignal aus. Ein RSI-Aufstieg über 70 deutet auf einen Überkauf und löst ein Verkaufssignal aus.

Bollinger-Bänder sind obere/untere Bands, die aus dem gleitenden Durchschnitt des Preises und der Standardabweichung berechnet werden, um festzustellen, ob der Preis aus dem normalen Schwankungsbereich ausgebrochen ist.

Die S/R-Komponente verwendet eine dynamische Berechnungsmethode, um Schlüssel-S/R-Levels zu generieren, die auf historischen Hoch-/Tiefpreisen (oder Schließ-/Offnpreisen) innerhalb bestimmter Rückblicksperioden und Prozentsatzbereiche sowie historischen Preisumkehrpunkten basieren.

Zusammenfassend lässt sich sagen, dass diese Strategie nur dann Kauf-/Verkaufstransaktionen einleitet, wenn der RSI überkauft/überverkauft, der Preis aus den Bollinger-Bändern ausbricht und die Nähe zu dynamischen S/R-Niveaus erreicht ist.

Vorteile

Der Grundindikator RSI kombiniert mit dem Indikator der technischen Analyse Bollinger Bands. Der RSI beurteilt überkaufte/überverkaufte Niveaus grundlegend, während Bollinger Bands technische Preismuster bestimmt.
Dynamische S/R-Berechnung entspricht näher den tatsächlichen S/R, die die Preisbewegung bestimmen.
Das Hinzufügen eines Trendfilters verbessert die Genauigkeit des Signals weiter, indem es in Kombination mit RSI und Bollinger Bands Lärm filtert.

Risiken

Eine falsche Einstellung der RSI-Parameter kann zu Fehleinschätzungen führen. Eine zu kurze RSI-Länge erhöht das Rauschen. Eine falsche Einstellung der überkauften/überverkauften Schwelle führt ebenfalls zu Fehlern.
Falsche Bollinger-Bänderparameter wie Länge, StdDev-Multiplikator beeinflussen die Richtigkeit der Beurteilung.
Dynamische S/R basiert auf historischen Hoch-/Niedrigpreisen und neigt daher dazu, zu verzögern.
Diese Strategie hat eine relativ komplexe Logik mit mehreren Indikatoren, die möglicherweise Störungen verursachen. Benutzer sollten Parameter testen, um Konflikte zu reduzieren. Die Vereinfachung der Einstiegskriterien hilft auch, Fehler zu minimieren.

Optimierungsrichtlinien

Test und Optimierung von RSI-Parametern einschließlich Länge, Überkauf-/Überverkaufsschwellen.
Test und Optimierung der Bollinger-Band-Parameter einschließlich Länge und StdDev-Multiplikator.
Optimieren dynamischer S/R-Parameter, um die S/R-Level näher an den Preis anzupassen, z. B. durch kürzere Rückblickzeiten oder weniger historische Hoch-/Tiefpreise.
Test zusätzliche Hilfsindikatoren in Kombination mit dem RSI, wie KDJ, MACD usw. zur Verbesserung der Genauigkeit.
Test und Optimierung der Trendfilterparameter, insbesondere der Filterlänge, um die Aufbewahrungsdauer zu verlängern und unnötige Umkehrbestellungen zu reduzieren.

Schlussfolgerung

Diese Strategie nutzt die Stärken mehrerer Indikatoren wie RSI, Bollinger Bands und Dynamic S/R, mit umfangreicher Querverifizierung für eine robuste Signalgenauigkeit. Das Hinzufügen eines Trendfilters reduziert den Lärm weiter. Mit flexiblem Parameter-Tuning können Benutzer diese Strategie optimieren, um ihren Bedürfnissen am besten zu entsprechen. Richtige Parameterprüfung und -optimierung führen zu einer ausgeprägteren Leistung. Dies ist eine vielversprechende quantitative Strategie.

/*backtest
start: 2023-01-17 00:00:00
end: 2024-01-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("RSI + BB + S/R Strategy with Trend Filter", shorttitle="RSI + BB + S/R + Trend Filter", overlay=true)

// RSI Settings
rsi_length = input.int(14, title="RSI Length")
overbought = input.int(70, title="Overbought Level")
oversold = input.int(30, title="Oversold Level")

// Bollinger Bands Settings
bb_length = input.int(20, title="BB Length")
bb_deviation = input.float(2.0, title="BB Deviation")

// Dynamic Support/Resistance Settings
pivot_period = input.int(10, title="Pivot Period")
pivot_source = input.string("High/Low", title="Pivot Source", options=["High/Low", "Close/Open"])
max_pivots = input.int(20, title="Maximum Number of Pivot", minval=5, maxval=100)
channel_width = input.int(10, title="Maximum Channel Width %", minval=1)
max_sr_levels = input.int(5, title="Maximum Number of S/R Levels", minval=1, maxval=10)
min_strength = input.int(2, title="Minimum Strength", minval=1, maxval=10)

// Trend Filter Settings
use_trend_filter = input.bool(false, title="Use Trend Filter")
trend_filter_length = input.int(50, title="Trend Filter Length")

// Calculate RSI and Bollinger Bands
rsi = ta.rsi(close, rsi_length)
basis = ta.sma(close, bb_length)
deviation = ta.stdev(close, bb_length)
upper_band = basis + bb_deviation * deviation
lower_band = basis - bb_deviation * deviation

// Plot Bollinger Bands on the chart
plot(upper_band, color=color.blue, title="Upper Bollinger Band")
plot(lower_band, color=color.red, title="Lower Bollinger Band")

// Dynamic Support/Resistance Calculation
float src1 = pivot_source == "High/Low" ? high : math.max(close, open)
float src2 = pivot_source == "High/Low" ? low : math.min(close, open)
float ph = ta.pivothigh(src1, pivot_period, pivot_period)
float pl = ta.pivotlow(src2, pivot_period, pivot_period)


// Calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * channel_width / 100

var pivotvals = array.new_float(0)

if ph or pl
    array.unshift(pivotvals, ph ? ph : pl)
    if array.size(pivotvals) > max_pivots
        array.pop(pivotvals)

get_sr_vals(ind) =>
    float lo = array.get(pivotvals, ind)
    float hi = lo
    int numpp = 0
    for y = 0 to array.size(pivotvals) - 1 by 1
        float cpp = array.get(pivotvals, y)
        float wdth = cpp <= lo ? hi - cpp : cpp - lo
        if wdth <= cwidth
            if cpp <= hi
                lo := math.min(lo, cpp)
            else
                hi := math.max(hi, cpp)
            numpp += 1
    [hi, lo, numpp]

var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)

find_loc(strength) =>
    ret = array.size(sr_strength)
    for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
        if strength <= array.get(sr_strength, i)
            break
        ret := i
    ret

check_sr(hi, lo, strength) =>
    ret = true
    for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
        if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
            if strength >= array.get(sr_strength, i)
                array.remove(sr_strength, i)
                array.remove(sr_up_level, i)
                array.remove(sr_dn_level, i)
            else
                ret := false
            break
    ret

if ph or pl
    array.clear(sr_up_level)
    array.clear(sr_dn_level)
    array.clear(sr_strength)
    for x = 0 to array.size(pivotvals) - 1 by 1
        [hi, lo, strength] = get_sr_vals(x)
        if check_sr(hi, lo, strength)
            loc = find_loc(strength)
            if loc < max_sr_levels and strength >= min_strength
                array.insert(sr_strength, loc, strength)
                array.insert(sr_up_level, loc, hi)
                array.insert(sr_dn_level, loc, lo)
                if array.size(sr_strength) > max_sr_levels
                    array.pop(sr_strength)
                    array.pop(sr_up_level)
                    array.pop(sr_dn_level)

// Calculate the Trend Filter
trend_filter = use_trend_filter ? ta.sma(close, trend_filter_length) : close

// Buy Condition (RSI + Proximity to Support + Trend Filter)
buy_condition = ta.crossover(rsi, oversold) and close <= ta.highest(high, max_sr_levels) and close >= ta.lowest(low, max_sr_levels) and (not use_trend_filter or close > trend_filter)

// Sell Condition (RSI + Proximity to Resistance + Trend Filter)
sell_condition = ta.crossunder(rsi, overbought) and close >= ta.lowest(low, max_sr_levels) and close <= ta.highest(high, max_sr_levels) and (not use_trend_filter or close < trend_filter)

// Strategy Orders
strategy.entry("Buy", strategy.long, when = buy_condition)
strategy.entry("Sell", strategy.short, when = sell_condition)

Mehr