क्वाड्रैटिक फ़िट ट्रेडिंग सिग्नल रणनीति


निर्माण तिथि: 2023-09-23 15:40:57 अंत में संशोधित करें: 2023-09-23 15:40:57
कॉपी: 2 क्लिक्स: 627
1
ध्यान केंद्रित करना
1617
समर्थक

अवलोकन

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

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

इस रणनीति के मुख्य घटक और नियम इस प्रकार हैं:

  1. उच्च और निम्न बिंदुओं के अनुरूपः K रेखा के उच्च और निम्न बिंदुओं के अनुरूप न्यूनतम द्विगुणित माध्यमिक वक्रों का उपयोग करना

  2. खरीद संकेतः जब K लाइन बंद होने की कीमत ऊपर की ओर बढ़ जाती है तो खरीद संकेत उत्पन्न होता है।

  3. बेचने का संकेत: जब K लाइन बंद होने की कीमत नीचे की पट्टी को तोड़ती है तो एक बेचने का संकेत होता है।

  4. N चक्र सत्यापनः एक ब्रेकडाउन के लिए N चक्रों की आवश्यकता होती है, ताकि झूठे ब्रेकडाउन से बचा जा सके।

  5. सम स्थिति संकेत: कोई स्पष्ट सम स्थिति संकेत नहीं है, रिटर्न्स ऑप्टिमाइज़ेशन द्वारा स्थिति रखने का समय निर्धारित किया गया है।

यह रणनीति एक गणितीय मॉडल के माध्यम से महत्वपूर्ण कीमतों की पहचान करने का प्रयास करती है, और जब वे टूट जाते हैं तो प्रवेश करते हैं, जो कि एक विशिष्ट ब्रेकआउट सिस्टम है।

श्रेष्ठता विश्लेषण

इस रणनीति के अन्य ब्रीच सिस्टम की तुलना में मुख्य फायदे हैंः

  1. गणित के मॉडल का उपयोग करके, एक व्यक्तिपरक से अधिक निष्पक्ष निर्णय लें।

  2. यह व्यापारिक तकनीक और सांख्यिकीय मॉडल का एक नया संयोजन है।

  3. मल्टी-साइकल सत्यापन की शुरूआत, झूठी दरारों को फ़िल्टर करने के लिए

  4. रिटर्न्स ऑप्टिमाइज़ेशन सबसे अच्छा समय पकड़ने के लिए खोज करता है।

  5. यह आसान है और इसे आसानी से बदला जा सकता है।

  6. मॉडल को मैन्युअल रखरखाव के बिना स्वचालित रूप से अपडेट किया जाता है।

  7. विभिन्न किस्मों और चक्रों के पैरामीटर के लिए फिटनेस की जांच की जा सकती है।

  8. मशीन लर्निंग को आगे के अनुकूलन और सत्यापन के लिए पेश किया जा सकता है।

  9. कुल मिलाकर, यह एक उच्च स्तर की नवीनता है और इसकी खोज करने लायक है।

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

लेकिन इस रणनीति के साथ निम्नलिखित जोखिम भी हैं:

  1. मिलान प्रभाव पैरामीटर के चयन पर निर्भर करता है, जो अति-अनुकूलित हो सकता है।

  2. अनुपालन वक्र में देरी के कारण, नुकसान को पूरी तरह से टाला नहीं जा सकता है।

  3. लेनदेन की मात्रा को ध्यान में नहीं रखते हुए, एक जोखिम है।

  4. सांख्यिकीय व्यय को दीर्घकालिक स्थिरता के लिए अतिरिक्त लाभ प्राप्त करना मुश्किल है।

  5. यह एक छोटी प्रतिक्रिया अवधि है और मॉडल की स्थिरता को सत्यापित करने के लिए आवश्यक है।

  6. बहु-प्रजाति पर्यावरण अनुकूलता का परीक्षण किया जाना है।

  7. स्थिर स्थिति को गतिशील रूप से समायोजित नहीं किया जा सकता है।

  8. आय वापसी अनुपात का सख्ती से आकलन करें।

अनुकूलन दिशा

उपरोक्त विश्लेषण के आधार पर, इस रणनीति में निम्नलिखित पहलुओं में सुधार किया जा सकता हैः

  1. विभिन्न बाजार स्थितियों में परीक्षण पैरामीटर की मजबूती।

  2. लेनदेन की मात्रा को सत्यापित करने के संकेतकों में शामिल होना।

  3. लॉग इन और आउट को अनुकूलित करें और सिग्नल की गुणवत्ता में सुधार करें।

  4. एक गतिशील स्थिति प्रबंधन मॉडल स्थापित करना

  5. स्टॉप लॉस रणनीति को लागू करना।

  6. धन प्रबंधन रणनीति का अनुकूलन करना

  7. अनुवर्ती विंडो स्क्रॉल सत्यापित करें.

  8. कई किस्मों की स्थिर आय क्षमता का आकलन करना

  9. मशीन लर्निंग का उपयोग करके मॉडल का अनुकूलन करना।

संक्षेप

समग्र रूप से, इस रणनीति में कुछ नवीनता और प्रायोगिक मूल्य है। हालांकि, सांख्यिकीय मध्यस्थता की दीर्घकालिक स्थिरता अभी भी परीक्षण के सामने है। रणनीति की स्थिरता, जोखिम और लाभप्रदता की स्थिति को पूरी तरह से समीक्षा करने की आवश्यकता है, ताकि रणनीति को बदलते बाजारों में अनुकूलनशीलता बनाए रखने के लिए ओवरफिट को रोका जा सके।

रणनीति स्रोत कोड
/*backtest
start: 2023-08-23 00:00:00
end: 2023-09-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

strategy(title = " Strategy Quadratic Semaphore ",
         shorttitle = "SQS",
         overlay = true,
         precision = 8,
         calc_on_order_fills = true,
         calc_on_every_tick = true,
         backtest_fill_limits_assumption = 0,
         default_qty_type = strategy.fixed,
         default_qty_value = 2,
         initial_capital = 10000,
         pyramiding=5,
         currency = currency.USD,
         linktoseries = true)

//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

backTestSectionFrom = input(title = "═══════════════ From ═══════════════", defval = true, type = input.bool)

FromMonth         = input(defval = 1, title = "Month", minval = 1)
FromDay           = input(defval = 1, title = "Day", minval = 1)
FromYear          = input(defval = 2019, title = "Year", minval = 2014)

backTestSectionTo = input(title = "════════════════ To ════════════════", defval = true, type = input.bool)
ToMonth           = input(defval = 31, title = "Month", minval = 1)
ToDay             = input(defval = 12, title = "Day", minval = 1)
ToYear            = input(defval = 9999, title = "Year", minval = 2014)

Config            = input(title = "══════════════ Config ══════════════", defval = true, type = input.bool)
p = input(6)
length = input(30)
//
backTestPeriod() => (time > timestamp(FromYear, FromMonth, FromDay, 00, 00)) and (time < timestamp(ToYear, ToMonth, ToDay, 23, 59))
//
//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

x1 = bar_index
x2 = sqrt(x1)
y = high
//
S11 = sum(x2,length) - sqrt(sum(x1,length)) / length  
S12 = sum(x1*x2,length) - (sum(x1,length) * sum(x2,length)) / length  
S22 = sum(sqrt(x2),length) - sqrt(sum(x2,length)) / length            
Sy1 = sum (y*x1,length) - (sum(y,length) * sum(x1,length)) / length   
Sy2 = sum (y*x2,length) - (sum(y,length) * sum(x2,length)) / length   
//
max1 = sma(x1,length) 
max2 = sma(x2,length)
may = sma(y,length)
b2 = ((Sy1 * S22) - (Sy2*S12))/(S22*S11 - sqrt(S12))
b3 = ((Sy2 * S11) - (Sy1 * S12))/(S22 * S11 - sqrt(S12))
b1 = may - b2*max1 - b3*max2
qr = b1 + b2*x1 + b3*x2
//
yl = low
//
Sy1l = sum(yl*x1,length) - (sum(yl,length) * sum(x1,length)) / length  
Sy2l = sum(yl*x2,length) - (sum(yl,length) * sum(x2,length)) / length  
//
mayl = sma(yl,length)
b2l = ((Sy1l * S22) - (Sy2l*S12))/(S22*S11 - sqrt(S12))
b3l = ((Sy2l * S11) - (Sy1l * S12))/(S22 * S11 - sqrt(S12))
b1l = mayl - b2l*max1 - b3l*max2
qrl = b1l + b2l*x1 + b3l*x2
//
period = round(p/2)+1
hh = qr[period]
ll = qrl[period]
countH = 0
countL = 0
buy=0
sell=0
//
for i = 1 to period-1
    if qr[i]<hh
        countH:=countH+1
    if qrl[i]>ll
        countL:=countL+1

for i = period+1 to p+1
    if qr[i]<hh
        countH:=countH+1
    if qrl[i]>ll
        countL:=countL+1

if countH==p
    pivotH = high[period]
    buy := 1
    
if countL==p
    pivotL = low[period]
    sell := 1
//    
plotshape(buy == 1 , text='💣', style=shape.arrowup, location=location.belowbar, color=#32CD32, textcolor=color.white, offset=0, transp=0,size=size.auto)
plotshape(sell == 1 , text='🔨', style=shape.arrowdown, location=location.abovebar, color=#FF0000, textcolor=color.white, offset=0, transp=0,size=size.auto)
//

if (backTestPeriod())
    strategy.entry("long", true, 1, when = buy == 1)
    strategy.entry("short", false, 1, when = sell == 1)