Die Ressourcen sind geladen. Beförderung...

Divergenz-Matrix-Trend nach Strategie

Schriftsteller:ChaoZhang, Datum: 12.12.2023
Tags:

Übersicht

Die Divergenzmatrix Trend Following Strategie ist eine quantitative Handelsstrategie, die Trend-, Divergenz- und gleitende Durchschnittsanalyse kombiniert. Diese Strategie verwendet doppelte RSI-Indikatoren, um die Markttrendrichtung zu beurteilen, und Matrix-gleitende Durchschnitte, um Einstiegssignale zu generieren. Die Matrix-gleitenden Durchschnitte passen die Positionsgröße basierend auf dem Grad der Preisdivergenz an. Insgesamt besteht der Vorteil dieser Strategie darin, Handelssignale mit mehreren Indikatoren zu bestätigen, die falsche Ausbrüche effektiv vermeiden können.

Strategie Logik

Die Divergenzmatrix Trend Following Strategie besteht aus folgenden Hauptteilen:

Doppel-RSI für die Trendbeurteilung

Verwenden Sie den schnellen und langsamen RSI, um die Markttrendrichtung zu bestimmen.
Matrix gleitender Durchschnitt für Handelssignale

Setzen Sie eine Gruppe von Matrix gleitenden Durchschnitten basierend auf dem Einstiegspreis ein. Wenn der Preis eine gleitende Durchschnittslinie berührt, passen Sie die Position entsprechend an. Dies ermöglicht mehr Gewinne in Trends zu erfassen.
Bidirektionales Handel

Der Standard ist ein bidirektionales Trading.

Die spezifische Handelslogik lautet:

Verwenden Sie einen schnellen RSI, um vorübergehende Überkauf-/Überverkaufswerte auf dem Markt zu erkennen.
Verwenden Sie einen langsamen RSI, um die mittelfristige bis langfristige Trendrichtung des Marktes zu bestimmen.
Wenn der schnelle RSI Extreme zeigt und der langsame RSI eine Trendumkehr anzeigt, werden Positionen auf der Grundlage des langen/kurzen Trends durch den langsamen RSI aufgenommen.
Diese Matrixlinien basieren auf dem Einstiegspreis, wobei die Intervallgröße im Parameter Matrix Interval % definiert ist.
Wenn der Preis eine Matrixlinie berührt, passen Sie die Positionsgröße entsprechend an.
Wenn der Preis große Anpassungen erlebt, werden die Positionen auf das Ausgangsniveau zurückgesetzt.

Das oben beschriebene beschreibt die wichtigste Handelslogik dieser Strategie.

Vorteile

Die Divergenzmatrix Trend Following Strategie hat folgende Vorteile:

Ein schneller RSI verhindert falsche Ausbrüche und ein langsamer RSI stellt sicher, dass der Haupttrend korrekt ist.
Matrix gleitende Durchschnitte profitieren von Trends. Die Anpassung der Positionsgröße basierend auf der Preisdivergenz ermöglicht die Erfassung von nachhaltigen Gewinnen.
Unterstützt den bidirektionalen Handel. Standardmäßig handelt es sich um den bidirektionalen Handel, kann aber auch nur lang gehen. Dies passt sich an mehr Marktumgebungen an.
Der Mechanismus des Positionsrücksetzens kontrolliert Risiken.
Flexible Parameter-Einstellungen: Benutzer können optimale Parameterkombinationen auf der Grundlage historischer Daten, Handelsinstrumente usw. auswählen.
Eine klare Trennung der Aufgaben macht den Code leicht verständlich, zu optimieren und zu erweitern.

Zusammenfassend ist der größte Vorteil dieser Strategie die Verbesserung der Signalqualität durch mehrere Mechanismen bei gleichzeitiger Verfolgung höherer Renditen unter kontrollierten Risiken.

Risiken

Die Strategie "Divergenzmatrix Trend Following" birgt auch einige Risiken, hauptsächlich in den folgenden Bereichen:

Das Risiko eines Fehlers von doppelten RSI-Signalen. Wenn der Markt im Bereich ist, gibt der RSI oft falsche Signale. Es ist manuelles Eingreifen erforderlich, um die Parameter anzupassen oder den Handel auszusetzen.
Unzulängliche Matrix-Durchschnittsrisiken. Wenn die Matrixparameter nicht richtig eingestellt sind, können Positionsanpassungen zu aggressiv sein, wodurch die Verluste vergrößert werden.
Das Risiko von überfinanzierten Positionen Übermäßige Anpassungen der Positionsgröße werden auch zu Verlusten führen.
Das Risiko einer Trendumkehr: Wenn bei einer Trendumkehr keine Positionen umgehend geschlossen werden, können große Verluste entstehen.
Diese Strategie ist bereits recht ausgereift. Das fortgesetzte Optimierungspotenzial ist begrenzt. Große Upgrades können erforderlich sein, wenn sich die Marktregime drastisch ändern.

Die Bewertung und Optimierung der Strategie ist der Schlüssel zur Minderung dieser Risiken - die Anpassung von Parametern, die Überwachung längerfristiger Indikatoren usw. können die Risiken bis zu einem gewissen Grad mindern.

Möglichkeiten zur Verbesserung

Der Trend der Divergenzmatrix kann weiter verbessert werden:

Optimieren Sie doppelte RSI-Parameter. Testen Sie mehr Parameterkombinationen und wählen Sie RSI-Perioden mit höchster Genauigkeit aus.
Anpassungsfähige Matrixlinien. Ermöglichen Sie Benutzern, die Matrix-Einstellungen auf der Grundlage verschiedener Instrumente zu parametrieren, um ihre Eigenschaften besser zu erfüllen.
Fügen Sie Stop-Loss-Mechanismen hinzu, z. B. setzen Sie Exit-Linien ein, um Positionen zu stoppen, wenn der Preis diese Linien bricht.
Fügen Sie mehr wissenschaftliche Positionsgrößenregeln hinzu und verwalten Sie Positionsgrößenanpassungen schrittweise, um Überhebungen zu vermeiden.
Einbeziehung anderer Indikatoren, Einführung zusätzlicher Indikatoren wie MACD, KD usw. zur Verbesserung der Signalgenauigkeit.
Optimierung der Code-Struktur und weitere Verbesserung der Erweiterbarkeit, Wartungsfähigkeit und Ausführungsfähigkeit des Codes.

Schlussfolgerung

Die Divergenz-Matrix-Trend-Folge-Strategie ist eine ausgeklügelte quantitative Handelsstrategie, die mehrere Mechanismen kombiniert - mit doppelter RSI für die Trendrichtung und Matrixlinien, um von Trends zu profitieren. Im Vergleich zu Einzelindikator-Strategien liefert sie stabilere und effizientere Handelssignale. Mit Parameter-Tuning und Optimierungserweiterungen kann sich diese Strategie an mehr Marktbedingungen und -regime anpassen, was sie sehr vielseitig macht. Insgesamt erreicht diese Strategie ein gutes Gleichgewicht zwischen Risiko und Rendite und verdient eine aktive Anwendung und kontinuierliche Verbesserung durch Anleger.

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

//@version=3
strategy("The Matrix 7.0 Strategy", overlay=false)

//Matrix Settings 
entry_size = input(title="Entry Size", defval = 1)
max_size = input(title="Max Size", defval = 10000)
matrix = input(title="Matrix Interval %", defval = 2)
matrix_price_overwrite = input(title="Matrix Overwrite $", defval = 0.0)
adjustment = input(title="Adjustment Size", defval = 1000)
trade_short = input(title="Trade Short", type=bool, defval = true)

//RSI Settings
periods = input(title="RSI Periods", defval = 14)
overbought_short = input(title="RSI Overbought", defval = 65)
oversold_short = input(title="RSI Oversold", defval = 30)

//RSI Trend Settings
resolution_long = input(title="Resolution Trend", defval = "D")
periods_long = input(title="RSI Trend Periods", defval = 14)
overbought_long = input(title="RSI Trend Overbought", defval = 64)
oversold_long = input(title="RSI Trend Oversold", defval = 30)

//Round Off to 2 decimals
round2(x) =>
    a = x * 10 * 10
    a := floor(a + 0.5)
    a := a / 10 / 10
    a

//RSI Function
RSI = rsi(close, periods)

//RSI Market Function
rsi_oversold = RSI < oversold_short
rsi_overbought = RSI > overbought_short

market_rsi = 0.0
market_rsi := if (rsi_oversold)
    RSI - oversold_short
else
    if (rsi_overbought)
        RSI - overbought_short
    else
        0

//RSI Trend Function
rsi_long = request.security(syminfo.tickerid,resolution_long,rsi(close,periods_long))
trend_rsi_long = rsi_long < oversold_long
trend_rsi_short = rsi_long > overbought_long
trend_rsi = 0
trend_rsi := if (trend_rsi_short)
    -1
else
    if (trend_rsi_long)
        1
    else
        trend_rsi[1] 

// // Shorter time resolution to make "close" crosses give faster positives.
// short_resolution = security(tickerid, "1", close)
// quick = round2(short_resolution) //ROUND OFF TO 2 DECIMAL PLACES.

//Declare Other Variables
entry_price = 0.0
entry_price := nz(entry_price[1])

position_size = 0.0
position_size := nz(position_size[1])

last_traded_price = 0.0
last_traded_price := nz(last_traded_price[1])


matrix_price = 0.0
if matrix_price_overwrite > 0.0
    matrix_price := matrix_price_overwrite
else
    matrix_price := round2((matrix/100) * entry_price)

level = 0
level := nz(level[1])

level_price = entry_price
if not na(level_price[1])
    level_price := level_price[1]

// Calculate Level
if close > level_price 
    level_change = floor((high - level_price)/matrix_price)
    level := level + level_change
else
    if close < level_price 
        level_change = ceil((low - level_price)/matrix_price)
        level := level + level_change
        
// Calculate Level Price   
level_price := (level * matrix_price) + entry_price

// Calculate Matrix Position
matrix_position = 0.0

if position_size > 0
    matrix_position :=  ((-1 * level) * adjustment) + entry_size
else
    if position_size < 0
        matrix_position :=  ((-1 * level) * adjustment) - entry_size
    
//Trend Entry or Reversal Conditions
trend_reversal_up = trend_rsi == 1 and (trend_rsi[1] == -1 or trend_rsi == 0) and position_size <= 0
trend_reversal_down = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == true
flatten_position = trend_rsi == -1 and (trend_rsi[1] == 1 or trend_rsi == 0) and position_size >= 0 and trade_short == false

//Reset Conditions
reset_long = (position_size > 0) and (close - entry_price > matrix_price) and (market_rsi < 0) and (position_size != entry_size) 
reset_short = (position_size < 0) and (entry_price - close > matrix_price) and (market_rsi > 0) and (position_size != (-1 * entry_size)) 

//Adjustment Conditions
increase_long = (position_size > 0) and (matrix_position > position_size) and (market_rsi < 0) and (matrix_position <= max_size) 
decrease_long = (position_size > 0) and (matrix_position < position_size) and (market_rsi > 0) 
increase_short = (position_size < 0) and (matrix_position < position_size) and (market_rsi > 0) and (matrix_position >= (-1 * max_size)) 
decrease_short = (position_size < 0) and (matrix_position > position_size) and (market_rsi < 0)  

//Transactions
//Trend Reversals
if trend_reversal_up
    strategy.entry("OL", strategy.long, qty=entry_size)
    position_size := entry_size
    matrix_position := entry_size
    level := 0
else
    if trend_reversal_down 
        strategy.entry("OS", strategy.short, qty=entry_size)
        position_size := -1 * entry_size
        matrix_position := -1 * entry_size   
        level := 0
        
    //Reset Positions    
    else
        if reset_long
            order = entry_size - position_size[1]
            strategy.order("RL", strategy.long, qty=order)
            position_size := entry_size
            matrix_position := entry_size
            level := 0
        else
            if reset_short
                order = position_size[1] - (-1* entry_size)
                strategy.order("RS", strategy.short, qty=order)
                position_size := -1 * entry_size
                matrix_position := -1 * entry_size
                level := 0

    //Position Adjustments
            else    
                if increase_long
                    order = matrix_position - position_size[1]
                    strategy.order("IL", strategy.long, qty=order)
                    position_size := position_size[1] + order
                else
                    if decrease_long
                        order = position_size[1] - matrix_position
                        strategy.order("DL", strategy.short, qty=order)
                        position_size := position_size[1] - order
                    else
                        if increase_short
                            order = position_size[1] - matrix_position
                            strategy.order("IS", strategy.short, qty=order)
                            position_size := position_size[1] - order
                        else
                            if decrease_short
                                order = matrix_position - position_size[1]
                                strategy.order("DS", strategy.long, qty=order)
                                position_size := position_size[1] + order
                            else 
                                if flatten_position
                                    strategy.close_all()
                                    position_size := 0.0
                                    matrix_position := 0.0
                                    level := 0

//Grouped Actions
if trend_reversal_up or trend_reversal_down or reset_short or reset_long
    entry_price := round2(close)
    last_traded_price := round2(close)

if increase_long or decrease_long or increase_short or decrease_short
    last_traded_price := round2(close)

// //RSI Trend & Adjustment Moments. (strategy)
p1 = plot(market_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Market', transp =0)
p2 = plot(trend_rsi, color = trend_rsi > 0 ? green : red, linewidth = 4, title='Trend', transp = 0)
fill(p1,p2, color=trend_rsi > 0 ? green : red, transp=0)
p3 = plot((rsi_long - 50) *2, color = white, title="Trend Index")
fill(p2,p3, color=white)
hline((overbought_long -50) * 2)
hline((oversold_long -50) * 2)

//Position Plots (strategy)
plot(matrix_position / 100, title='Matrix', color=white, linewidth = 4)
plot(position_size / 100, title='Position', color=blue, linewidth = 4)
plot(strategy.position_size / 100, title='Strategy', color=orange, linewidth = 4)

// //Price Plots (study)
// plot(level_price, title="Matrix Level Price", linewidth=4)
// plot(last_traded_price, title="Last Traded Price", linewidth=2, color=orange)
// plot(entry_price + (4 * matrix_price), title='Adjustment 4', color=white, linewidth = 1)
// plot(entry_price + (3 * matrix_price), title='Adjustment 3', color=white, linewidth = 1)
// plot(entry_price + (2 * matrix_price), title='Adjustment 2', color=white, linewidth = 1)
// plot(entry_price + matrix_price, title='Adjustment 1', color=white, linewidth = 1)
// plot(entry_price, title='Entry Price', color=white, linewidth = 3)
// plot(entry_price - matrix_price, title='Adjustment -1', color=white, linewidth = 1)
// plot(entry_price - (2 * matrix_price), title='Adjustment -2', color=white, linewidth = 1)
// plot(entry_price - (3 * matrix_price), title='Adjustment -3', color=white, linewidth = 1)
// plot(entry_price - (4 * matrix_price), title='Adjustment -4', color=white, linewidth = 1)


// //Alerts (study only)
// alertcondition(trend_reversal_up, title='Trend Reversal Up', message='Market Oversold, Lets Buy')
// alertcondition(trend_reversal_down, title='Trend Reversal Down', message='Market Overbought, Lets Sell')
// alertcondition(reset_long, title='Reset Long', message='Higher Bottom, Lets Buy')
// alertcondition(reset_short, title='Reset Short', message='Lower Top, Lets Sell')
// alertcondition(increase_long, title='Increase Long', message='Price Dropped, Lets Buy')
// alertcondition(decrease_long, title='Decrease Long', message='Price Spiked, Lets Sell')
// alertcondition(increase_short, title='Increase Short', message='Price Spiked, Lets Sell')
// alertcondition(decrease_short, title='Decrease Short', message='Price Dropped, Lets Buy')

// //Grouped Conditions
// condition_buy = trend_reversal_up or increase_long or decrease_short or reset_long
// condition_sell = trend_reversal_down or decrease_long or increase_short or reset_short
// adjustment_matrix = trend_reversal_up or increase_long or decrease_short or trend_reversal_down or decrease_long or increase_short or reset_long or reset_short

// //Grouped Alerts
// alertcondition(condition_buy, title='Condition Buy', message='You Need to Buy')
// alertcondition(condition_sell, title='Condition Sell', message='You Need to Sell!')
// alertcondition(adjustment_matrix, title='Adjustment Matrix', message='You Need to Adjust')

Mehr