Tendance de la matrice de divergence à la suite de la stratégie

Auteur:ChaoZhang est là., Date: le 12 décembre 2023 à 17h05
Les étiquettes:

Résumé

La stratégie de suivi de tendance de la matrice de divergence est une stratégie de trading quantitative qui combine l'analyse de tendance, de divergence et de moyenne mobile. Cette stratégie utilise des indicateurs RSI doubles pour juger de la direction de la tendance du marché et des moyennes mobiles de matrice pour générer des signaux d'entrée.

La logique de la stratégie

La stratégie de suivi de la tendance de la matrice de divergence se compose des parties principales suivantes:

Indicateur de risque double pour l'évaluation de la tendance

Utilisez le RSI rapide et le RSI lent pour déterminer la direction de la tendance du marché.
Moyenne mobile de matrice pour les signaux de négociation

Configurez un groupe de moyennes mobiles de matrice basé sur le prix d'entrée. Lorsque le prix touche une ligne moyenne mobile, ajustez la position en conséquence. Cela permet de capturer plus de profits dans les tendances.
Commerce bidirectionnel

Le trading bidirectionnel est par défaut.

La logique de négociation spécifique est la suivante:

Utilisez un RSI rapide pour repérer les niveaux temporaires de surachat/survente sur le marché.
Utilisez un RSI lent pour déterminer la direction de la tendance du marché à moyen et long terme.
Lorsque le RSI rapide montre des extrêmes et que le RSI lent signale un renversement de tendance, prenez des positions basées sur la tendance longue/courte par le RSI lent.
Après avoir entré des positions, définissez un groupe de moyennes mobiles de matrice.
Lorsque le prix touche une ligne de matrice, ajustez la taille de la position en conséquence.
Lorsque le prix subit des ajustements importants, les positions seront réinitialisées aux niveaux initiaux.

Ce qui précède décrit la principale logique de négociation de cette stratégie.

Les avantages

La stratégie de suivi des tendances de la matrice de divergence présente les avantages suivants:

Les signaux RSI doubles sont plus fiables. RSI rapide évite les fausses ruptures et RSI lent garantit que la tendance principale est correcte.
Les moyennes mobiles de matrice profitent des tendances. L'ajustement de la taille de la position en fonction de la divergence des prix permet de capturer des profits soutenus.
Il supporte le trading bidirectionnel. Le trading bidirectionnel est par défaut, mais peut aussi être long seulement.
Le mécanisme de réinitialisation des positions contrôle les risques.
Les utilisateurs peuvent sélectionner des combinaisons optimales de paramètres en fonction des données historiques, des instruments de négociation, etc.
Structure de code propre: une séparation claire des responsabilités facilite la compréhension, l'optimisation et l'extension du code.

En résumé, le plus grand avantage de cette stratégie est d'améliorer la qualité du signal grâce à de multiples mécanismes tout en poursuivant des rendements plus élevés sous des risques contrôlés.

Les risques

La stratégie de suivi des tendances de la matrice de divergence comporte également certains risques, principalement dans les domaines suivants:

Risque d'échec des signaux RSI doubles. Lorsque le marché est limité à une plage, le RSI donne souvent de faux signaux. Une intervention manuelle est nécessaire pour ajuster les paramètres ou suspendre le trading.
Si les paramètres de la matrice ne sont pas réglés correctement, les ajustements de position peuvent être trop agressifs, ce qui augmente les pertes.
Le risque de positions surendettées. Des ajustements excessifs de la taille des positions augmenteront également les pertes. Le paramètre de taille maximale des positions doit être défini avec prudence.
Risque d'inversion de tendance: si les positions ne sont pas fermées rapidement lorsque la tendance s'inverse, des pertes importantes peuvent être encourues.
Cette stratégie est déjà assez mature. Le potentiel d'optimisation continue est limité. Des mises à niveau majeures peuvent être nécessaires si les régimes du marché changent radicalement.

L'évaluation et l'optimisation de la stratégie sont essentielles pour atténuer ces risques: l'ajustement des paramètres, le suivi des indicateurs à plus long terme, etc., peuvent atténuer les risques dans une certaine mesure.

Des possibilités d'amélioration

Il est possible d'améliorer encore la tendance de la matrice de divergence selon la stratégie suivante:

Optimiser les paramètres RSI doubles. Tester plus de combinaisons de paramètres et sélectionner les périodes RSI avec la plus grande précision.
Lines de matrice personnalisables. Permet aux utilisateurs de paramétrer les paramètres de matrice basés sur différents instruments pour mieux s'adapter à leurs caractéristiques.
Ajoutez des mécanismes de stop-loss, par exemple, mettez en place des lignes de sortie pour arrêter les positions si le prix dépasse ces lignes.
Ajoutez des règles plus scientifiques pour la taille des positions. Gérez les ajustements de taille des positions de manière plus progressive pour éviter un effet de levier excessif.
Incorporer d'autres indicateurs. Introduire des indicateurs supplémentaires comme MACD, KD etc. pour améliorer la précision du signal.
Optimiser la structure du code, améliorer encore l'extensibilité, la maintenance et l'efficacité d'exécution du code.

Conclusion

La stratégie de suivi des tendances de la matrice de divergence est une stratégie de trading quantitative sophistiquée combinant plusieurs mécanismes - en utilisant un double RSI pour la direction de la tendance et des lignes de matrice pour tirer profit des tendances. Par rapport aux stratégies à indicateur unique, elle fournit des signaux de trading plus stables et efficaces. Avec des extensions de réglage et d'optimisation de paramètres, cette stratégie peut s'adapter à plus de conditions et de régimes de marché, ce qui la rend très polyvalente.

/*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')

Plus de

2019 FMZ - Tous les droits réservés