संसाधन लोड हो रहा है... लोड करना...

थरथरानवाला मोमबत्ती गति व्यापार रणनीति

लेखक:चाओझांग, दिनांक: 2023-09-26 20:05:55
टैगः

अवलोकन

यह एक गति-आधारित रणनीति है जो ट्रेडिंग संकेत उत्पन्न करने के लिए आरएसआई, स्टॉक, एमएसीडी जैसे ऑसिलेटर संकेतकों का उपयोग करती है। मुख्य विचार यह है कि संकेतकों का उपयोग करके मूल्य दोलन के दौरान प्रवृत्ति की दिशा की पहचान करना और संकेतकों के संकेतों के आधार पर ट्रेड करना। यह रणनीति स्टॉप लॉस के लिए विलंबित सुपरट्रेंड का भी उपयोग करती है।

रणनीति तर्क

रणनीति पहले कस्टम फ़ंक्शन f_getOscilatorValues को RSI, स्टॉक, MACD आदि सहित विभिन्न ऑसिलेटर संकेतकों के मान प्राप्त करने के लिए कॉल करती है। फिर यह स्टॉप लॉस को ट्रैक करने के लिए f_getSupertrend के साथ विलंबित सुपरट्रेंड मानों की गणना करती है।

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

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

प्रवेश के बाद, स्टॉप लॉस को ऊपरी/निम्न बैंड द्वारा पीछा किया जाता है जो भी करीब है। जब स्टॉप लॉस ट्रिगर किया जाता है, तो स्थिति बंद हो जाती है। जब कीमत लाभ लक्ष्य तक पहुंच जाती है, तो आंशिक लाभ लिया जाता है।

लाभ विश्लेषण

इस रणनीति के लाभ इस प्रकार हैंः

  1. रुझान की दिशा की पहचान करने के लिए ऑसिलेटरों का उपयोग करने से अल्पकालिक उलट अवसरों को समय पर पकड़ लिया जा सकता है।

  2. विलंबित सुपरट्रेंड स्टॉप लॉस लागू करने से हानि बढ़ने से पहले रोक दिया जा सकता है, जिससे एकल व्यापार हानि सीमित हो जाती है।

  3. गतिशील एटीआर के आधार पर स्टॉप लॉस और लाभ लक्ष्य की गणना करने से स्थिति आकार को समायोजित करने में मदद मिलती है।

  4. उच्च समय सीमा वाले चलती औसत के साथ फ़िल्टर करने से समेकन में फंसने से बचा जाता है।

  5. आंशिक लाभ लेने से कुछ लाभ प्राप्त होता है।

  6. क्वांट ट्रेडिंग के शुरुआती लोगों के लिए तर्क सरल और समझने में आसान है।

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

इस रणनीति के कुछ जोखिमों में शामिल हैंः

  1. ऑसिलेटर में देरी से आने वाले मुद्दे हो सकते हैं, जिससे देरी से प्रवेश और समय से पहले बाहर निकलने के संकेत हो सकते हैं। यह मापदंडों को अनुकूलित करके या ट्रेंड फॉलोइंग संकेतकों को जोड़कर सुधार किया जा सकता है।

  2. स्ट्रेट स्टॉप लॉस को हिट किया जा सकता है। स्टॉप लॉस रेंज को बढ़ाया जा सकता है या चैंडेलर जैसे गतिशील स्टॉप का उपयोग किया जा सकता है।

  3. आंशिक लाभ लेने के बाद शेष स्थिति को बंद किया जा सकता है। आंशिक लाभ अनुपात को कम किया जा सकता है।

  4. बैकटेस्ट ओवरफिट जोखिम। रणनीति को विभिन्न बाजारों में मान्य किया जाना चाहिए।

  5. उच्च समय सीमा चलती औसत फ़िल्टर की विफलता। प्रवृत्ति वर्गीकरण विधियों का उपयोग एक साथ किया जाना चाहिए।

सुधार दिशाएँ

इस रणनीति को निम्नलिखित पहलुओं में अनुकूलित किया जा सकता हैः

  1. ऑसिलेटर मापदंडों के विभिन्न संयोजनों का परीक्षण करें और उन लोगों को खोजें जो गुणवत्ता संकेत प्रदान करते हैं।

  2. ATR या चलती औसत के आधार पर आंशिक लाभ लेने के साथ लाभ बंद करने की कोशिश करें।

  3. प्रवृत्ति विश्लेषण के लिए चलती औसत की जगह लेने और सटीकता में सुधार के लिए मशीन लर्निंग एल्गोरिदम जोड़ें।

  4. अनावश्यक उलटा करने से बचने के लिए फ़िल्टरिंग स्थितियों के रूप में वॉल्यूम संकेतक जोड़ें।

  5. परिसंपत्ति के लिए इष्टतम संयोजन खोजने के लिए संकेतकों को इकट्ठा करें और वजन करें।

  6. गतिशील रूप से स्टॉप, लक्ष्य और स्थिति आकार अनुकूलित करने के लिए मशीन लर्निंग जोखिम नियंत्रण मॉड्यूल जोड़ें।

  7. वायदा और स्पॉट के बीच मूल्य स्प्रेड का उपयोग करके त्रिकोणीय मध्यस्थता या आधार व्यापार संकेत शामिल करें।

निष्कर्ष

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


/*backtest
start: 2023-08-26 00:00:00
end: 2023-09-25 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © HeWhoMustNotBeNamed

//@version=4
strategy("Oscilator candles - strategy", overlay=false, initial_capital = 1000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, pyramiding = 1, commission_value = 0.01, calc_on_order_fills = true)

oscilatorType = input(title="Oscliator Type", defval="stoch", options=["rsi", "stoch", "cog", "macd", "tsi", "cci", "cmo", "mfi"])
length = input(3)
shortlength = input(3)
longlength = input(9)

showSupertrend = input(true)
AtrMAType = input(title="Moving Average Type", defval="rma", options=["ema", "sma", "hma", "rma", "vwma", "wma"])
AtrLength = input(30, step=10)
stopMultiplier  = input(4)
targetMultiplier  = input(3)
wicks = input(true)
considerWicksForDelayByStep = input(false)
colorByPreviousClose = input(true)

useHTFPivot = input(false)
resolution = input("12M", type=input.resolution)
HTFMultiplier = input(4, title="Higher Timeframe multiplier (Used when resolution is set to Same as Symbol)", minval=2, step=1)
PivotLength = input(2, step=1)

tradeDirection = input(title="Trade Direction", defval=strategy.direction.long, options=[strategy.direction.all, strategy.direction.long, strategy.direction.short])
i_startTime = input(defval = timestamp("01 Jan 2010 00:00 +0000"), title = "Backtest Start Time", type = input.time)
i_endTime = input(defval = timestamp("01 Jan 2099 00:00 +0000"), title = "Backtest End Time", type = input.time)
inDateRange = true

f_getOscilatorValues(oscilatorType, length, shortlength, longlength)=>
    oOpen = rsi(open, length)
    oClose = rsi(close, length)
    oHigh = rsi(high, length)
    oLow = rsi(low, length)
    if(oscilatorType == "tsi")
        oOpen := tsi(open, shortlength, longlength)
        oClose := tsi(close, shortlength, longlength)
        oHigh := tsi(high, shortlength, longlength)
        oLow := tsi(low, shortlength, longlength)
    if(oscilatorType == "stoch")
        oOpen := stoch(open, longlength, shortlength, length)
        oClose := stoch(close, longlength, shortlength, length)
        oHigh := stoch(high, longlength, shortlength, length)
        oLow := stoch(low, longlength, shortlength, length)
    if(oscilatorType == "cci")
        oOpen := cci(open, length)
        oClose := cci(close, length)
        oHigh := cci(high, length)
        oLow := cci(low, length)
    if(oscilatorType == "cog")
        oOpen := cog(open, length)
        oClose := cog(close, length)
        oHigh := cog(high, length)
        oLow := cog(low, length)
    if(oscilatorType == "cmo")
        oOpen := cmo(open, length)
        oClose := cmo(close, length)
        oHigh := cmo(high, length)
        oLow := cmo(low, length)
    if(oscilatorType == "mfi")
        oOpen := mfi(open, length)
        oClose := mfi(close, length)
        oHigh := mfi(high, length)
        oLow := mfi(low, length)
    if(oscilatorType == "macd")
        [macdLineOpen, signalLineOpen, histLineOpen] = macd(open, shortlength, longlength, length)
        [macdLineClose, signalLineClose, histLineClose] = macd(close, shortlength, longlength, length)
        [macdLineHigh, signalLineHigh, histLineHigh] = macd(high, shortlength, longlength, length)
        [macdLineLow, signalLineLow, histLineLow] = macd(low, shortlength, longlength, length)
        oOpen := macdLineOpen
        oClose := macdLineClose
        oHigh := macdLineHigh
        oLow := macdLineLow
    [oOpen, oClose, oHigh, oLow]

f_getMovingAverage(source, MAType, length)=>
    ma = sma(source, length)
    if(MAType == "ema")
        ma := ema(source,length)
    if(MAType == "hma")
        ma := hma(source,length)
    if(MAType == "rma")
        ma := rma(source,length)
    if(MAType == "vwma")
        ma := vwma(source,length)
    if(MAType == "wma")
        ma := wma(source,length)
    ma

f_getSupertrend(oOpen, oClose, oHigh, oLow, AtrMAType, AtrLength, stopMultiplier, wicks)=>
    truerange = max(oHigh, oClose[1]) - min(oLow, oClose[1])
    
    averagetruerange = f_getMovingAverage(truerange, AtrMAType, AtrLength)
    atr = averagetruerange * stopMultiplier

    longStop = oClose - atr
    longStopPrev = nz(longStop[1], longStop)
    longStop := (wicks ? oLow[1] : oClose[1]) > longStopPrev ? max(longStop, longStopPrev) : longStop
    
    shortStop = oClose + atr
    shortStopPrev = nz(shortStop[1], shortStop)
    shortStop := (wicks ? oHigh[1] : oClose[1]) < shortStopPrev ? min(shortStop, shortStopPrev) : shortStop
    
    dir = 1
    dir := nz(dir[1], dir)
    dir := dir == -1 and (wicks ? oHigh : oClose) > shortStopPrev ? 1 : dir == 1 and (wicks ? oLow : oClose) < longStopPrev ? -1 : dir
    
    trailingStop = dir == 1? longStop : shortStop
    
    [dir, trailingStop]


f_getBuySellStops(oOpen, oClose, oHigh, oLow, AtrMAType, AtrLength, considerWicks, considerWicksForDelayByStep, stopMultiplier, targetMultiplier)=>
    barState = 0
    source = oClose
    
    truerange = max(oHigh, oClose[1]) - min(oLow, oClose[1])
    
    atr = f_getMovingAverage(truerange, AtrMAType, AtrLength)

    buyStop = source - atr * stopMultiplier
    sellStop = source + atr * stopMultiplier
    buyStopDerived = buyStop
    sellStopDerived = sellStop
    highTarget = considerWicks ? oHigh : source
    lowTarget = considerWicks ? oLow : source
    
    highTargetDelayByStep = considerWicksForDelayByStep ? oHigh : source
    lowTargetDelayByStep = considerWicksForDelayByStep ? oLow : source
    
    barState := highTarget > sellStopDerived[1] ? 1 : lowTarget < buyStopDerived[1] ? -1 : nz(barState[1],0)
    
    buyMultiplier = (barState == 1)? stopMultiplier : targetMultiplier
    sellMultiplier = (barState == -1)? stopMultiplier : targetMultiplier
    buyStop := source - atr * buyMultiplier
    sellStop := source + atr * sellMultiplier
    buyStop := barState == 1? max(buyStop, buyStop[1]) : barState == -1? min(buyStop, buyStop[1]) : buyStop
    sellStop := barState == 1? max(sellStop, sellStop[1]) : barState == -1? min(sellStop, sellStop[1]) : sellStop
    
    buyStopDerived := buyStop
    sellStopDerived := sellStop
    
    buyStopDerived := highTargetDelayByStep < sellStopDerived[1] and lowTargetDelayByStep > buyStopDerived[1] ? buyStopDerived[1] : buyStopDerived
    sellStopDerived := highTargetDelayByStep < sellStopDerived[1] and lowTargetDelayByStep > buyStopDerived[1] ? sellStopDerived[1] : sellStopDerived

    [buyStopDerived, sellStopDerived, barState]


f_secureSecurity(_symbol, _res, _src) => security(_symbol, _res, _src[1], lookahead = barmerge.lookahead_on, gaps=barmerge.gaps_off)

f_multiple_resolution(HTFMultiplier) => 
    target_Res_In_Min = timeframe.multiplier * HTFMultiplier * (
      timeframe.isseconds   ? 1. / 60. :
      timeframe.isminutes   ? 1. :
      timeframe.isdaily     ? 1440. :
      timeframe.isweekly    ? 7. * 24. * 60. :
      timeframe.ismonthly   ? 30.417 * 24. * 60. : na)

    target_Res_In_Min     <= 0.0417       ? "1S"  :
      target_Res_In_Min   <= 0.167        ? "5S"  :
      target_Res_In_Min   <= 0.376        ? "15S" :
      target_Res_In_Min   <= 0.751        ? "30S" :
      target_Res_In_Min   <= 1440         ? tostring(round(target_Res_In_Min)) :
      tostring(round(min(target_Res_In_Min / 1440, 365))) + "D"
    
f_getPivotHighLow(oOpen, oClose, oHigh, oLow, HTFMultiplier, resolution, PivotLength)=>
    derivedResolution = resolution == ""? f_multiple_resolution(HTFMultiplier) : resolution
    HTFHigh = f_secureSecurity(syminfo.tickerid, derivedResolution, oHigh)
    HTFLow = f_secureSecurity(syminfo.tickerid, derivedResolution, oLow)
    CLOSEprev = f_secureSecurity(syminfo.tickerid, derivedResolution, oClose)
    pivothi = pivothigh(HTFHigh, PivotLength, PivotLength)
    pivotlo = pivotlow(HTFLow, PivotLength, PivotLength)
    pivothi := na(pivothi)? nz(pivothi[1]) : pivothi
    pivotlo := na(pivotlo)? nz(pivotlo[1]) : pivotlo
    [pivothi, pivotlo]
    
[oOpen, oClose, oHigh, oLow] = f_getOscilatorValues(oscilatorType, length, shortlength, longlength)
[dir, trailingStop] = f_getSupertrend(oOpen, oClose, oHigh, oLow, AtrMAType, AtrLength, stopMultiplier, wicks)

candleColor = colorByPreviousClose ?
                 (oClose[1] < oClose ? color.green : oClose[1] > oClose ? color.red : color.silver) : 
                 (oOpen < oClose ? color.green : oOpen > oClose ? color.red : color.silver)
plotcandle(oOpen, oHigh, oLow, oClose, 'Oscilator Candles', color = candleColor)

[buyStopDerived, sellStopDerived, barState] = f_getBuySellStops(oOpen, oClose, oHigh, oLow, AtrMAType, AtrLength, wicks, considerWicksForDelayByStep, stopMultiplier, targetMultiplier)

trailingStopDerived = barState == 1? buyStopDerived : sellStopDerived

plot(showSupertrend?trailingStopDerived:na, title="TrailingStop", style=plot.style_linebr, linewidth=1, color= barState == 1 ? color.green : color.red)

[pivotHigh, pivotLow] = f_getPivotHighLow(open, close, high, low, HTFMultiplier, resolution, PivotLength)

buyCondition = (barState == 1) and (close > pivotHigh or not useHTFPivot)
exitBuyConditin = (barState == -1)
sellCondition = (barState == -1) and (close < pivotLow or not useHTFPivot)
exitSellCondition = (barState == 1)

// strategy.risk.allow_entry_in(tradeDirection)
strategy.entry("Buy", strategy.long, when=buyCondition and inDateRange, oca_name="oca")
strategy.entry("Sell", strategy.short, when=sellCondition and inDateRange, oca_name="oca")
strategy.close("Buy", when = exitBuyConditin)
strategy.close( "Sell", when = exitSellCondition)

अधिक