संसाधन लोड हो रहा है... लोड करना...
  1. वर्ग
  2. गतिशील आरएसआई-मूल्य विचलन का पता लगाने और अनुकूलन ट्रेडिंग रणनीति प्रणाली

गतिशील आरएसआई-मूल्य विचलन का पता लगाने और अनुकूलन ट्रेडिंग रणनीति प्रणाली

लेखक:चाओझांग, दिनांकः 2025-01-10 16:20:25
टैगःआरएसआईटीपीSL

Dynamic RSI-Price Divergence Detection and Adaptive Trading Strategy System

अवलोकन

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

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

रणनीति का मूल तर्क निम्नलिखित प्रमुख तत्वों पर आधारित हैः 1. आरएसआई विचलन का पता लगाना: आरएसआई संकेतकों और मूल्य रुझानों के उच्च और निम्न की तुलना करके संभावित विचलन पैटर्न की पहचान करता है। मंदी विचलन बिक्री संकेत तब बनते हैं जब मूल्य नए उच्च बनाता है जबकि आरएसआई नहीं करता है; तेजी से विचलन खरीद संकेत तब बनते हैं जब मूल्य नए निम्न बनाता है जबकि आरएसआई नहीं करता है। 2. फ्रैक्टल पुष्टिकरण: मूल्य संरचना का विश्लेषण करने के लिए फ्रैक्टल सिद्धांत का उपयोग करता है, सिग्नल विश्वसनीयता में सुधार के लिए स्थानीय उच्च और निम्न का पता लगाकर विचलन वैधता की पुष्टि करता है। 3. पैरामीटर अनुकूलन: विभिन्न बाजार वातावरणों के अनुकूलन को प्राप्त करते हुए फ्रैक्टल निर्णय अंतराल को गतिशील रूप से समायोजित करने के लिए संवेदनशीलता पैरामीटर पेश करता है। 4. जोखिम नियंत्रणः प्रत्येक व्यापार के लिए नियंत्रित जोखिम सुनिश्चित करने के लिए प्रतिशत आधारित स्टॉप लॉस और टेक प्रॉफिट तंत्र को एकीकृत करता है।

रणनीतिक लाभ

  1. उच्च सिग्नल विश्वसनीयता: आरएसआई विचलन और फ्रैक्टल्स सिद्धांत की दोहरी पुष्टि तंत्र व्यापार सिग्नल सटीकता में काफी सुधार करता है।
  2. अनुकूलन क्षमताः रणनीति विभिन्न बाजार स्थितियों के अनुसार मापदंडों को लचीले ढंग से समायोजित कर सकती है, जिससे पर्यावरण अनुकूलन क्षमता अच्छी दिखती है।
  3. व्यापक जोखिम प्रबंधन: एकीकृत गतिशील स्टॉप-लॉस और लाभ लेने की तंत्र प्रत्येक व्यापार के लिए जोखिम जोखिम को प्रभावी ढंग से नियंत्रित करते हैं।
  4. उच्च स्वचालन स्तरः सिग्नल की पहचान से लेकर व्यापार निष्पादन तक पूर्ण स्वचालन मानव हस्तक्षेप से भावनात्मक प्रभाव को कम करता है।
  5. अच्छी स्केलेबिलिटीः रणनीति ढांचे में बहु-उपकरण, बहु-समय-सीमा अनुप्रयोगों का समर्थन किया गया है, जिससे पोर्टफोलियो निवेश को सुविधाजनक बनाया गया है।

रणनीतिक जोखिम

  1. बाजार परिवेश पर निर्भरता: प्रवृत्ति वाले बाजारों में विचलन संकेत की विश्वसनीयता कम हो सकती है, जिसके लिए अतिरिक्त प्रवृत्ति फ़िल्टरिंग तंत्र की आवश्यकता होती है।
  2. पैरामीटर संवेदनशीलता: आरएसआई सीमाओं और फ्रैक्टल निर्णय अंतराल जैसे प्रमुख मापदंडों को सावधानीपूर्वक ट्यून करने की आवश्यकता होती है, अनुचित पैरामीटर सेटिंग्स रणनीति प्रदर्शन को प्रभावित कर सकती हैं।
  3. सिग्नल लेगः सिग्नल की पुष्टि करने से पहले पूर्ण विचलन पैटर्न के गठन की प्रतीक्षा करने से प्रवेश समय में देरी हो सकती है।
  4. बाजार शोर हस्तक्षेपः अस्थिर बाजारों में झूठे विचलन के संकेत हो सकते हैं, जिसके लिए अतिरिक्त फ़िल्टरिंग स्थितियों की आवश्यकता होती है।

रणनीति अनुकूलन दिशाएं

  1. प्रवृत्ति फ़िल्टरिंग जोड़ेंः मजबूत प्रवृत्ति बाजारों में विपरीत प्रवृत्ति संकेतों को फ़िल्टर करने के लिए प्रवृत्ति निर्णय संकेतक पेश करें, विभिन्न बाजार वातावरणों में रणनीति अनुकूलन क्षमता में सुधार करें।
  2. मापदंड अनुकूलन को अनुकूलित करना: बाजार की अस्थिरता के आधार पर गतिशील मापदंड समायोजन तंत्र विकसित करना, बाजार परिवर्तनों के लिए रणनीति प्रतिक्रिया को बढ़ाना।
  3. जोखिम नियंत्रण में सुधारः बाजार की अस्थिरता के आधार पर स्टॉप-लॉस पदों को स्वचालित रूप से समायोजित करने के लिए गतिशील स्टॉप-लॉस तंत्र पेश करें, धन प्रबंधन प्रभावों को अनुकूलित करें।
  4. सिग्नल पुष्टिकरण में सुधारः वॉल्यूम, अस्थिरता और अन्य बाजार सूक्ष्म संरचना संकेतकों को मिलाकर एक अधिक व्यापक सिग्नल पुष्टिकरण प्रणाली का निर्माण करें।

सारांश

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

/*backtest
start: 2025-01-02 00:00:00
end: 2025-01-09 00:00:00
period: 5m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":49999}]
*/

//FRACTALS
//@version=5

//last : 30m 70 68 22 25 0 0 4.7 11.5

//init
capital=1000
percent=100
fees=0//in percent for each entry and exit

//Inputs
start = input(timestamp("1 Feb 2002"), "Start Time", group = "Date")
end = input(timestamp("1 Feb 2052"), "End Time", group = "Date")

//Strategy
strategy("Divergence Finder (RSI/Price) Strategy with Options", overlay = true, initial_capital=capital, default_qty_value=percent, default_qty_type=strategy.percent_of_equity, commission_type=strategy.commission.percent, calc_on_order_fills=false,process_orders_on_close=true , commission_value=fees, currency=currency.EUR, calc_on_every_tick=true, use_bar_magnifier=false)
//indicator("Divergence Finder (RSI/Price) with Options", overlay=true, max_boxes_count=200, max_bars_back=500,max_labels_count=500)


srcUp=input.source(close, "Source for Price Buy Div", group="sources")
srcDn=input.source(close, "Source for Price Sell Div", group="sources")
srcRsi=input.source(close, "Source for RSI Div", group="sources")


HighRSILimit=input.int(70, "Min RSI for Sell divergence (p1:pre last)", group="signals", inline="1", step=1)
HighRSILimit2=input.int(68, "Min RSI for Sell divergence (p2):last", group="signals", inline="1", step=1)
LowRSILimit=input.int(22, "Min RSI for Buy divergence (p1:pre last)", group="signals", inline="2", step=1)
LowRSILimit2=input.int(25, "Min RSI for Buy divergence (p2:last)", group="signals", inline="2", step=1)


minMarginP=input.float(0, "Min margin between price for displaying divergence (%)", group="signals", step=0.01)
minMarginR=input.float(0, "Min margin between RSI for displaying divergence (%)", group="signals", step=1)

nb=input.int(2, "Sensivity: Determine how many candle will be used to determine last top or bot (too high cause lag, too low cause repaint)", group="Sensivity", inline="3", step=1)


stopPer= input.float(4.7, title='Stop %', group = "Per", inline="3", step=0.01)
tpPer = input.float(11.5, title='TP %', group = "Per", inline="4", step=0.01)

//nb=2
leftBars = nb
rightBars=nb


labels=input.bool(true, "Display Divergence labels", group="Display")
draw=input.bool(true, "Display tops/bottoms")



dnFractal = (close[nb-2] < close[nb]) and (close[nb-1] < close[nb]) and (close[nb+1] < close[nb]) and (close[nb+2] < close[nb])
upFractal = (close[nb-2] > close[nb]) and (close[nb-1] > close[nb]) and (close[nb+1] > close[nb]) and (close[nb+2] > close[nb])
ph=dnFractal
pl=upFractal

plot(dnFractal and draw ? close[nb] : na, style=plot.style_line,offset=-2, color=color.lime, title="tops")
plot(upFractal and draw ? close[nb] : na,  style=plot.style_line, offset=-2, color=color.red, title="botts")

plotchar(dnFractal ? high[nb] : na, char='⮝',location=location.absolute,offset=-2, color=color.rgb(236, 255, 63), title="Down Fractal")
plotchar(upFractal ? low[nb] : na, char='⮟', location=location.absolute, offset=-2, color=color.rgb(67, 227, 255), title="Up Fractal")


float myRSI=ta.rsi(srcRsi, 14)

bool divUp=false
bool divDn=false

//compare lasts bots
p2=ta.valuewhen( ph,srcDn[nb], 0 ) //last price
p1=ta.valuewhen( ph,srcDn[nb], 1 ) //pre last price

r2=ta.valuewhen( ph,myRSI[nb], 0 )  //last rsi
r1=ta.valuewhen( ph,myRSI[nb], 1 )  //pre last rsi


if ph
    if p1 < p2// - (p2 * minMarginP)/100
        if r1 > HighRSILimit and r2 > HighRSILimit2
            if r1 > r2 + (r2 * minMarginR)/100
                divDn:=true

plot(divDn ? close:na, style=plot.style_cross, linewidth=3, color= color.red, offset=-rightBars, title="Sell Div")
if labels and divDn and strategy.position_size >= 0
    label.new(bar_index-nb,high, "Sell Divergence "+str.tostring(p1)+"   "+str.tostring(math.round(r1, 2))+"  "+str.tostring(p2)+"   "+str.tostring(math.round(r2, 2)),xloc=xloc.bar_index,yloc=yloc.abovebar, color = color.red, style = label.style_label_down)
else if divDn and strategy.position_size >= 0
    label.new(bar_index-nb,high, "Sell Divergence",xloc=xloc.bar_index,yloc=yloc.abovebar, color = color.red, style = label.style_label_down)



p2:=ta.valuewhen( pl,srcUp[nb], 0 )
p1:=ta.valuewhen( pl,srcUp[nb], 1 )

r2:=ta.valuewhen( pl,myRSI[nb], 0 )
r1:=ta.valuewhen( pl,myRSI[nb], 1 )


if pl
    if p1 > p2 + (p2 * minMarginP)/100
        if r1 < LowRSILimit and r2 < LowRSILimit2
            if r1 < r2 - (r2 * minMarginR)/100
                divUp:=true
               
plot(divUp ? close:na, style=plot.style_cross, linewidth=3, color= color.green, offset=-rightBars, title="Buy Div")
if labels and divUp and strategy.position_size <= 0
    label.new(bar_index-nb,high, "Buy Divergence "+str.tostring(p1)+"   "+str.tostring(math.round(r1, 2))+"  "+str.tostring(p2)+"   "+str.tostring(math.round(r2, 2)),xloc=xloc.bar_index,yloc=yloc.belowbar, color = color.green, style = label.style_label_up)
else if divUp and strategy.position_size <= 0
    label.new(bar_index-nb,high, "Buy Divergence",xloc=xloc.bar_index,yloc=yloc.belowbar, color = color.green, style = label.style_label_up)


//strat LONG
longEntry = divUp//  and strategy.position_size == 0
longExit = divDn//  and strategy.position_size == 0

//strat SHORT
shortEntry = divDn
shortExit = divUp

LongActive=input(true, title='Activate Long', group = "Directions", inline="2")
ShortActive=input(true, title='Activate Short', group = "Directions", inline="2")
//StopActive=input(false, title='Activate Stop', group = "Directions", inline="2")


//tpActive =  input(false, title='Activate Take Profit', group = "TP", inline="4")
//RR=input(0.5, title='Risk Reward Multiplier', group = "TP")
//QuantityTP = input(100.0, title='Trade Ammount %', group = "TP")


//calc stop
//longStop = strategy.position_avg_price * (1 - stopPer)
//shortStop = strategy.position_avg_price * (1 + stopPer)

longStop = strategy.position_avg_price - (strategy.position_avg_price * stopPer/100)
shortStop = strategy.position_avg_price + (strategy.position_avg_price * stopPer/100)

longTP = strategy.position_avg_price + (strategy.position_avg_price * tpPer/100)
shortTP = strategy.position_avg_price - (strategy.position_avg_price * tpPer/100)

//Calc TP
//longTP = ((strategy.position_avg_price-longStop)*RR+strategy.position_avg_price)
//shortTP = (strategy.position_avg_price-((shortStop-strategy.position_avg_price)*RR))


//display stops
plot(strategy.position_size > 0 ? longStop : na, style=plot.style_linebr, color=color.red, linewidth=1, title="Long Fixed SL")
plot(strategy.position_size < 0 ? shortStop : na, style=plot.style_linebr, color=color.purple, linewidth=1, title="Short Fixed SL")


//display TP
plot(strategy.position_size > 0 ? longTP : na, style=plot.style_linebr, color=color.green, linewidth=1, title="Long Fixed TP")
plot(strategy.position_size < 0 ? shortTP : na, style=plot.style_linebr, color=color.green, linewidth=1, title="Short Fixed TP")

//do
if true
    //check money available
    if strategy.equity > 0
        //if tpActive //Need to put TP before Other exit
        strategy.exit("Close Long", from_entry="Long", limit=longTP,stop=longStop, comment="Close Long with : "+ str.tostring(math.round(strategy.equity)) +" $ ", qty_percent=100)
        strategy.exit("Close Short", from_entry="Short", limit=shortTP,stop=shortStop, comment="Close Short with : "+ str.tostring(math.round(strategy.equity)) +" $ ", qty_percent=100)
        //Set Stops
        //if StopActive
        //    strategy.exit("Stop Long", from_entry="Long", stop=longStop, comment="Stop Long with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
        //    strategy.exit("Stop Short", from_entry="Short", stop=shortStop, comment="Stop Short with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
        if longEntry
            if ShortActive
                strategy.close("Short",comment="Close Short with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
                alert("Close Short")
            if LongActive
                strategy.entry("Long", strategy.long, comment="Open Long with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
                alert("Open Long")
        if longExit
            if LongActive
                strategy.close("Long",comment="Close Long with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
                alert("Close Long")
            if ShortActive
                strategy.entry("Short", strategy.short, comment="Open Short with : "+ str.tostring(math.round(strategy.equity)) +" $ ")
                alert("Open Short")


//alertcondition(longEntry and LongActive, title="Buy Divergence Open", message="Buy Divergence Long Opened!")
//alertcondition(longExit and ShortActive, title="Sell Divergence Open", message="Buy Divergence Short Opened!")

//alertcondition(longExit and LongActive, title="Buy Divergence Closed", message="Buy Divergence Long Closed!")
//alertcondition(longEntry and ShortActive, title="Sell Divergence Closed", message="Buy Divergence Short Closed!")
संबंधित
अधिक

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