संसाधन लोड हो रहा है... लोड करना...
  1. वर्ग
  2. बहु-कारक मॉडल पर आधारित क्षण उलट रणनीति

बहु-कारक मॉडल पर आधारित क्षण उलट रणनीति

लेखक:चाओझांग, दिनांक: 2023-12-21 16:26:10
टैगः

img

अवलोकन

मल्टी-फैक्टर मॉडल पर आधारित मोमेंट रिवर्सल रणनीति अधिक स्थिर और उच्च रिटर्न प्राप्त करने के लिए मल्टी-फैक्टर मॉडल और गति रिवर्सल रणनीति को जोड़ती है। रणनीति 123 रिवर्सल और कन्फ्लुएंस संकेतक को दो स्वतंत्र संकेतों के रूप में उपयोग करती है और एक स्थिति स्थापित करती है जब दो संकेत सुसंगत होते हैं।

रणनीतिक सिद्धांत

इस रणनीति में दो उप-रणनीतियां शामिल हैंः 123 रिवर्स रणनीति और संगम सूचक रणनीति।

123 रिवर्स रणनीति ट्रेडिंग सिग्नल उत्पन्न करती है कि क्या कीमत 2 दिनों के लिए लगातार बढ़ी है या गिर गई है, यह तय करने के लिए स्टोच संकेतक के साथ संयुक्त है कि क्या बाजार ओवरकोल्ड या ओवरहीट है। विशेष रूप से, जब कीमत 2 दिनों के लिए लगातार बढ़ती है और 9-दिवसीय स्टोच धीमी रेखा 50 से नीचे है, तो यह तेजी है। जब कीमत 2 दिनों के लिए लगातार गिरती है और 9-दिवसीय स्टोच फास्ट लाइन 50 से ऊपर है, तो यह मंदी है।

संगम सूचक रणनीति प्रवृत्ति की दिशा और शक्ति निर्धारित करने के लिए विभिन्न चक्रों के चलती औसत और थरथरानवाला की अतिव्यापीता का उपयोग करती है। इसमें रैखिक भार, साइन जोड़ और लंबी और छोटी गति का व्यापक रूप से न्याय करने के लिए अन्य विधियां शामिल हैं। संकेतक ग्रेड किया जाता है और 1 से 9 तक लौटता है जो मजबूत तेजी की गति को इंगित करता है और -1 से -9 जो मजबूत मंदी की गति को इंगित करता है।

अंत में, रणनीति लंबी या छोटी स्थिति स्थापित करती है जब दोनों संकेत समान होते हैं।

लाभ विश्लेषण

मल्टी-फैक्टर मॉडल पर आधारित मोमेंट रिवर्सल स्ट्रेटेजी, झूठे ब्रेकआउट से बचने के लिए ट्रेंड का पालन करते हुए रिवर्सल अवसरों को पकड़ने के लिए रिवर्सल फैक्टर्स और इम्पैक्टम फैक्टर्स को जोड़ती है, इस प्रकार उच्च जीत दर होती है। इस रणनीति के फायदे विशेष रूप से निम्न में परिलक्षित होते हैंः

  1. रिवर्स सिग्नल स्रोत के रूप में, 123 रिवर्स रणनीति अल्पकालिक रिवर्स से अधिक रिटर्न प्राप्त कर सकती है।

  2. अभिसरण सूचक बहुत बड़े उलटविक्रय स्थान के कारण होने वाले नुकसान के जोखिम से बचने के लिए प्रवृत्ति की दिशा और शक्ति का आकलन करता है।

  3. दोनों रणनीतियों का संयोजन एक दूसरे की ताकत और कमजोरियों को कुछ हद तक पूरक करता है और सिग्नल की गुणवत्ता में सुधार करता है।

  4. एकल मॉडल की तुलना में, कई कारकों का संयोजन रणनीतियों की स्थिरता में सुधार कर सकता है।

जोखिम विश्लेषण

यद्यपि बहु-कारक मॉडल पर आधारित क्षण उलट रणनीति के कुछ फायदे हैं, फिर भी कुछ जोखिम हैंः

  1. रिवर्स न होने और कीमतों के फिर से घूमने के कारण होने वाले नुकसान का जोखिम। इसके खिलाफ सुरक्षा के लिए उचित स्टॉप लॉस सेट किया जा सकता है।

  2. दो संकेतों के असंगत होने पर दिशा निर्धारित करने में असमर्थ. मिलान की डिग्री बढ़ाने के लिए पैरामीटर समायोजन किया जा सकता है.

  3. मॉडल बहुत अधिक मापदंडों के साथ बहुत जटिल है, जिसे समायोजित करना और अनुकूलित करना मुश्किल है।

  4. कई उप-मॉडलों की एक साथ निगरानी करने की आवश्यकता होती है, जिसके परिणामस्वरूप संचालन में अधिक कठिनाई और मनोवैज्ञानिक दबाव होता है। परिचालन भार को कम करने के लिए स्वचालित व्यापार तत्वों को पेश किया जा सकता है।

अनुकूलन दिशाएँ

बहु-कारक मॉडल के आधार पर पलटाव रणनीति को निम्नलिखित पहलुओं में अनुकूलित किया जा सकता हैः

  1. 123 रिवर्स रणनीति के मापदंडों को समायोजित करें ताकि रिवर्स सिग्नल अधिक सटीक और विश्वसनीय हो सकें।

  2. निर्धारित रुझानों को वास्तविक रुझानों के करीब लाने के लिए संगम सूचक के मापदंडों को समायोजित करें।

  3. पैरामीटर संयोजनों को स्वचालित रूप से अनुकूलित करने के लिए मशीन लर्निंग एल्गोरिदम पेश करें।

  4. स्थिति समायोजन को अधिक मात्रात्मक और व्यवस्थित बनाने के लिए स्थिति प्रबंधन मॉड्यूल जोड़ें।

  5. स्टॉप लॉस मॉड्यूल जोड़ें. स्टॉप लॉस मूल्य पूर्व निर्धारित करके एकल हानि को प्रभावी ढंग से नियंत्रित करें.

सारांश

मल्टी-फैक्टर मॉडल पर आधारित मोमेंट रिवर्सल रणनीति व्यापक रूप से रिवर्सल कारकों और गति कारकों को नियोजित करती है। अपेक्षाकृत उच्च संकेत गुणवत्ता सुनिश्चित करने के आधार पर, यह मल्टी-फैक्टर स्टैकिंग के माध्यम से उच्च जीत दर प्राप्त करती है। रणनीति में रिवर्सल अवसरों को पकड़ने और प्रवृत्ति का पालन करने के दोहरे फायदे हैं। यह एक कुशल और स्थिर मात्रात्मक रणनीति है। रणनीति के जोखिम-इनाम अनुपात में और सुधार के लिए पैरामीटर समायोजन और जोखिम नियंत्रण जैसे पहलुओं में अनुवर्ती अनुकूलन किया जा सकता है।

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

//@version=4
////////////////////////////////////////////////////////////
//  Copyright by HPotter v1.0 11/11/2019
// This is combo strategies for get a cumulative signal. 
//
// First strategy
// This System was created from the Book "How I Tripled My Money In The 
// Futures Market" by Ulf Jensen, Page 183. This is reverse type of strategies.
// The strategy buys at market, if close price is higher than the previous close 
// during 2 days and the meaning of 9-days Stochastic Slow Oscillator is lower than 50. 
// The strategy sells at market, if close price is lower than the previous close price 
// during 2 days and the meaning of 9-days Stochastic Fast Oscillator is higher than 50.
//
// Second strategy
// This is modified version of Dale Legan's "Confluence" indicator written by Gary Fritz.
// ================================================================
// Here is Gary`s commentary:
// Since the Confluence indicator returned several "states" (bull, bear, grey, and zero), 
// he modified the return value a bit:
// -9 to -1 = Bearish
// -0.9 to 0.9 = "grey" (and zero)
// 1 to 9 = Bullish
// The "grey" range corresponds to the "grey" values plotted by Dale's indicator, but 
// they're divided by 10.
//
// WARNING:
// - For purpose educate only
// - This script to change bars colors.
////////////////////////////////////////////////////////////
Reversal123(Length, KSmoothing, DLength, Level) =>
    vFast = sma(stoch(close, high, low, Length), KSmoothing) 
    vSlow = sma(vFast, DLength)
    pos = 0.0
    pos := iff(close[2] < close[1] and close > close[1] and vFast < vSlow and vFast > Level, 1,
	         iff(close[2] > close[1] and close < close[1] and vFast > vSlow and vFast < Level, -1, nz(pos[1], 0))) 
	pos

Confluence(Harmonic, BuyBand, SellBand) =>
    pos = 0.0
    Price = close
    STL = round((Harmonic * 2) - 1 - 0.5)
    ITL = round((STL * 2) - 1 - 0.5)
    LTL = round((ITL * 2) - 1 - 0.5)
    HOFF = round(Harmonic / 2 - 0.5)
    SOFF = round(STL / 2 - 0.5)
    IOFF = round(ITL / 2 - 0.5)
    xHavg = sma(Price, Harmonic)
    xSavg = sma(Price, STL)
    xIavg = sma(Price, ITL)
    xLavg = sma(Price, LTL)
    xvalue2 = xSavg - xHavg[HOFF]
    xvalue3 = xIavg - xSavg[SOFF]
    xvalue12 = xLavg - xIavg[IOFF]
    xmomsig = xvalue2 + xvalue3 + xvalue12
    xLavgOHLC = sma(ohlc4, LTL - 1)
    xH2 = sma(Price, Harmonic - 1)
    xS2 = sma(Price, STL - 1)
    xI2 = sma(Price, ITL - 1)
    xL2 = sma(Price, LTL - 1)
    DerivH = (xHavg * 2) - xHavg[1]
    DerivS = (xSavg * 2) - xSavg[1]
    DerivI = (xIavg * 2) - xIavg[1]
    DerivL = (xLavg * 2) - xLavg[1]
    SumDH = Harmonic * DerivH
    SumDS = STL * DerivS
    SumDI = ITL * DerivI
    SumDL = LTL * DerivL
    LengH = Harmonic - 1
    LengS = STL - 1
    LengI = ITL - 1
    LengL = LTL - 1
    N1H = xH2 * LengH
    N1S = xS2 * LengS
    N1I = xI2 * LengI
    N1L = xL2 * LengL
    DRH = SumDH - N1H
    DRS = SumDS - N1S
    DRI = SumDI - N1I
    DRL = SumDL - N1L
    SumH = xH2 * (Harmonic - 1)
    SumS = xS2 * (STL - 1)
    SumI = xI2 * (ITL - 1)
    SumL = xLavgOHLC * (LTL - 1)
    xvalue5 = (SumH + DRH) / Harmonic
    xvalue6 = (SumS + DRS) / STL
    xvalue7 = (SumI + DRI) / ITL
    xvalue13 = (SumL + DRL) / LTL
    value9 = xvalue6 - xvalue5[HOFF]
    value10 = xvalue7 - xvalue6[SOFF]
    value14 = xvalue13 - xvalue7[IOFF]
    xmom = value9 + value10 + value14
    HT = sin(xvalue5 * 2 * 3.14 / 360) + cos(xvalue5 * 2 * 3.14 / 360)
    HTA = sin(xHavg * 2 * 3.14 / 360) + cos(xHavg * 2 * 3.14 / 360)
    ST = sin(xvalue6 * 2 * 3.14 / 360) + cos(xvalue6 * 2 * 3.14 / 360)
    STA = sin(xSavg * 2 * 3.14 / 360) + cos(xSavg * 2 * 3.14 / 360)
    IT = sin(xvalue7 * 2 * 3.14 / 360) + cos(xvalue7 * 2 * 3.14 / 360)
    ITA = sin(xIavg * 2 * 3.14 / 360) + cos(xIavg * 2 * 3.14 / 360)
    xSum = HT + ST + IT
    xErr = HTA + STA + ITA
    Condition2 = (((xSum > xSum[SOFF]) and (xHavg < xHavg[SOFF])) or ((xSum < xSum[SOFF]) and (xHavg > xHavg[SOFF])))
    Phase = iff(Condition2 , -1 , 1)
    xErrSum = (xSum - xErr) * Phase
    xErrSig = sma(xErrSum, SOFF)
    xvalue70 = xvalue5 - xvalue13
    xvalue71 = sma(xvalue70, Harmonic)
    ErrNum = iff (xErrSum > 0 and xErrSum < xErrSum[1] and xErrSum < xErrSig, 1,
                  iff (xErrSum > 0 and xErrSum < xErrSum[1] and xErrSum > xErrSig, 2, 
                     iff (xErrSum > 0 and xErrSum > xErrSum[1] and xErrSum < xErrSig, 2,
                         iff (xErrSum > 0 and xErrSum > xErrSum[1] and xErrSum > xErrSig, 3,
                          iff (xErrSum < 0 and xErrSum > xErrSum[1] and xErrSum > xErrSig, -1,
                             iff (xErrSum < 0 and xErrSum < xErrSum[1] and xErrSum > xErrSig, -2,
                              iff (xErrSum < 0 and xErrSum > xErrSum[1] and xErrSum < xErrSig, -2,
                                 iff (xErrSum < 0 and xErrSum < xErrSum[1] and xErrSum < xErrSig, -3, 0))))))))

    momNum = iff (xmom > 0 and xmom < xmom[1] and xmom < xmomsig , 1,
              iff (xmom > 0 and xmom < xmom[1] and xmom > xmomsig, 2,
               iff (xmom > 0 and xmom > xmom[1] and xmom < xmomsig, 2,
                 iff (xmom > 0 and xmom > xmom[1] and xmom > xmomsig, 3,
                  iff (xmom < 0 and xmom > xmom[1] and xmom > xmomsig, -1,
                   iff (xmom < 0 and xmom < xmom[1] and xmom > xmomsig, -2,
                     iff (xmom < 0 and xmom > xmom[1] and xmom < xmomsig, -2,
                      iff (xmom < 0 and xmom < xmom[1] and xmom < xmomsig, -3, 0))))))))
    
    TCNum =  iff (xvalue70 > 0 and xvalue70 < xvalue70[1] and xvalue70 < xvalue71, 1,
              iff (xvalue70 > 0 and xvalue70 < xvalue70[1] and xvalue70 > xvalue71, 2,
               iff (xvalue70 > 0 and xvalue70 > xvalue70[1] and xvalue70 < xvalue71, 2,
                 iff (xvalue70 > 0 and xvalue70 > xvalue70[1] and xvalue70 > xvalue71, 3,
                  iff (xvalue70 < 0 and xvalue70 > xvalue70[1] and xvalue70 > xvalue71, -1,
                   iff (xvalue70 < 0 and xvalue70 < xvalue70[1] and xvalue70 > xvalue71, -2,
                     iff (xvalue70 < 0 and xvalue70 > xvalue70[1] and xvalue70 < xvalue71, -2,
                      iff (xvalue70 < 0 and xvalue70 < xvalue70[1] and xvalue70 < xvalue71, -3,0))))))))
    
    value42 = ErrNum + momNum + TCNum
    Confluence = iff (value42 > 0 and xvalue70 > 0, value42,
                  iff (value42 < 0 and xvalue70 < 0, value42,
                   iff ((value42 > 0 and xvalue70 < 0) or (value42 < 0 and xvalue70 > 0), value42 / 10, 0)))
    Res1 = iff (Confluence >= 1, Confluence, 0)
    Res2 = iff (Confluence <= -1, Confluence, 0)
    Res3 = iff (Confluence == 0, 0, iff (Confluence > -1 and Confluence < 1, 10 * Confluence, 0))
    pos := iff(Res2 >= SellBand and Res2 != 0, -1,
	         iff(Res1 <= BuyBand and Res1 != 0, 1, 
    	      iff(Res3 != 0, 2, nz(pos[1], 0))))
    pos

strategy(title="Combo Backtest 123 Reversal & Confluence", shorttitle="Combo", overlay = true)
Length = input(14, minval=1)
KSmoothing = input(1, minval=1)
DLength = input(3, minval=1)
Level = input(50, minval=1)
//-------------------------
Harmonic = input(10, minval=1)
BuyBand = input(9)
SellBand = input(-9)
reverse = input(false, title="Trade reverse")
posReversal123 = Reversal123(Length, KSmoothing, DLength, Level)
posConfluence = Confluence(Harmonic, BuyBand, SellBand)
pos = iff(posReversal123 == 1 and posConfluence == 1 , 1,
	   iff(posReversal123 == -1 and posConfluence == -1, -1, 0)) 
possig = iff(reverse and pos == 1, -1,
          iff(reverse and pos == -1 , 1, pos))	   
if (possig == 1) 
    strategy.entry("Long", strategy.long)
if (possig == -1)
    strategy.entry("Short", strategy.short)	 
if (possig == 0) 
    strategy.close_all()
barcolor(possig == -1 ? #b50404: possig == 1 ? #079605 : #0536b3 )
अधिक

2019 FMZ - सभी अधिकार सुरक्षित