आरएसआई ट्रेंड फॉलोइंग ट्रेलिंग स्टॉप रणनीति


निर्माण तिथि: 2023-12-08 11:41:31 अंत में संशोधित करें: 2023-12-08 11:41:31
कॉपी: 3 क्लिक्स: 722
1
ध्यान केंद्रित करना
1621
समर्थक

आरएसआई ट्रेंड फॉलोइंग ट्रेलिंग स्टॉप रणनीति

अवलोकन

यह रणनीति एक स्वचालित ट्रेडिंग रणनीति है जो रुझान की पहचान करने के लिए आरएसआई संकेतक का उपयोग करती है और रुझान की पुष्टि करने के लिए एक चलती औसत के साथ मिलकर एक स्टॉपलॉस स्टॉप सेट करती है। जब आरएसआई 68 से अधिक है और वर्तमान चलती औसत से ऊपर है, तो चलती औसत से पहले अधिक करें; जब आरएसआई 28 से कम है और वर्तमान चलती औसत से नीचे है, तो चलती औसत से पहले खाली करें। साथ ही एक स्टॉपलॉस स्टॉप सेट करें।

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

यह रणनीति मुख्य रूप से RSI सूचकांक का उपयोग करके ओवरबॉय और ओवरसोल्ड घटनाओं की पहचान करती है। जब RSI 70 से अधिक होता है तो यह ओवरबॉय क्षेत्र होता है, और 30 से कम होने पर यह ओवरसोल्ड क्षेत्र होता है। गोल्डन क्रॉस और डेथ क्रॉस के साथ चलती औसत को मिलाकर ट्रेंड की पुष्टि की जाती है। विशिष्ट ट्रेडिंग सिग्नल हैंः

मल्टीहेड सिग्नलः आरएसआई 68 से अधिक है और वर्तमान चलती औसत पर चलने से पहले चलती औसत से अधिक है। खाली सिर सिग्नलः आरएसआई 28 से कम है और वर्तमान चलती औसत के नीचे से गुजरने से पहले चलती औसत, खाली करना।

स्टॉप लॉस स्टॉप सेटिंग्स प्रत्येक बिंदु के लिए एक अलग स्टॉप लॉस स्टॉप अनुपात सेट करते हैं, जो अधिक आराम से अधिक सख्त होते हैं, जैसेः

मल्टी हेड स्टॉपः 1.4% स्टॉप आधा स्थान, 0.8% स्टॉप पूरी तरह से खाली। मल्टीहेड स्टॉपः प्रवेश मूल्य का 2% सेट स्टॉप।

खाली सिर स्टॉपः 0.4% स्टॉप आधा स्थिति, 0.8% स्टॉप पूरी स्थिति।
खाली सिर रोकनाः प्रवेश मूल्य का 2% सेट रोकना।

जब रुझान पलट जाता है, उदाहरण के लिए, जब आरएसआई 30 से अधिक हो जाता है, तो बाजार की कीमत पूरी तरह से बर्फ हो जाती है; जब आरएसआई 60 से अधिक हो जाता है, तो बाजार की कीमत पूरी तरह से बर्फ हो जाती है।

रणनीतिक लाभ

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

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

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

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

अनुकूलन दिशा

इस तरह के कुछ और अनुकूलन हैं:

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

संक्षेप

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

रणनीति स्रोत कोड
// © CRabbit
//@version=5

// Starting with $100 and using 10% of the account per trade
strategy("RSI Template", shorttitle="RSI", overlay=false, initial_capital=100, default_qty_value=10, default_qty_type=strategy.percent_of_equity)

// RSI Indicator
ma(source, length, type) =>
    switch type
        "SMA" => ta.sma(source, length)
        "Bollinger Bands" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        "SMMA (RMA)" => ta.rma(source, length)
        "WMA" => ta.wma(source, length)
        "VWMA" => ta.vwma(source, length)

rsiLengthInput = input.int(4, minval=1, title="RSI Length", group="RSI Settings")
rsiSourceInput = input.source(close, "Source", group="RSI Settings")
maTypeInput = input.string("SMA", title="MA Type", options=["SMA", "Bollinger Bands", "EMA", "SMMA (RMA)", "WMA", "VWMA"], group="MA Settings")
maLengthInput = input.int(23, title="MA Length", group="MA Settings")
bbMultInput = input.float(2.0, minval=0.001, maxval=50, title="BB StdDev", group="MA Settings")

up = ta.rma(math.max(ta.change(rsiSourceInput), 0), rsiLengthInput)
down = ta.rma(-math.min(ta.change(rsiSourceInput), 0), rsiLengthInput)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsiMA = ma(rsi, maLengthInput, maTypeInput)
isBB = maTypeInput == "Bollinger Bands"

plot(rsi, "RSI", color=#7E57C2)
plot(rsiMA, "RSI-based MA", color=color.green)
rsiUpperBand = hline(70, "RSI Upper Band", color=#787B86)
hline(50, "RSI Middle Band", color=color.new(#787B86, 50))
rsiLowerBand = hline(30, "RSI Lower Band", color=#787B86)
fill(rsiUpperBand, rsiLowerBand, color=color.rgb(126, 87, 194, 90), title="RSI Background Fill")


// Configure backtest start date with inputs
startDate = input.int(title="Start Date", defval=1, minval=1, maxval=31)
startMonth = input.int(title="Start Month", defval=6, minval=1, maxval=12)
startYear = input.int(title="Start Year", defval=2022, minval=1800, maxval=2100)

// See if this bar's time happened on/after start date
afterStartDate = (time >= timestamp(syminfo.timezone,
     startYear, startMonth, startDate, 0, 0))


// Long and Short buy strategy
// Submit a market open/ close Long order, but only on/after start date
if (afterStartDate)
    if rsi > 68 and (rsiMA > rsiMA[1])
        strategy.entry("Long Order", strategy.long, comment="ENTER-LONG")
    if rsi < 30
        strategy.close("Long Order", alert_message="L-CL")

strategy.exit("L-TP1", from_entry="Long Order", limit=high * 1.004, qty_percent=50, alert_message="L-TP1" + str.tostring(high * 1.004))
strategy.exit("L-TP2", from_entry="Long Order", limit=high * 1.008, qty_percent=100, alert_message="L-TP2" + str.tostring(high * 1.008))
strategy.exit("Exit Long", from_entry="Long Order", stop=low * 0.98, alert_message="L-SL" + str.tostring(low * 0.98))        


// Submit a market Open/ Close Short order, but only on/after start date
if (afterStartDate)
    if rsi < 28 and (rsiMA < rsiMA[1])
        strategy.entry("Short Order", strategy.short, comment="ENTER-SHORT")
    if rsi > 60
        strategy.close("Short Order", alert_message="S-CL")    

strategy.exit("S-TP1", from_entry="Short Order", limit=low * 0.996, qty_percent=50, alert_message="S-TP1" + str.tostring(low * 0.996))
strategy.exit("S-TP2", from_entry="Short Order", limit=low * 0.992, qty_percent=100, alert_message="S-TP2" + str.tostring(low * 0.992))
strategy.exit("Exit Short", from_entry="Short Order", stop=high * 1.02, alert_message="S-SL" + str.tostring(high * 1.02))

// MONTHLY TABLE //

prec      = input(2, title = "Return Precision")

new_month = month(time) != month(time[1])
new_year  = year(time)  != year(time[1])

eq = strategy.equity

bar_pnl = eq / eq[1] - 1

cur_month_pnl = 0.0
cur_year_pnl  = 0.0

// Current Monthly P&L
cur_month_pnl := new_month ? 0.0 : 
                 (1 + cur_month_pnl[1]) * (1 + bar_pnl) - 1 

// Current Yearly P&L
cur_year_pnl := new_year ? 0.0 : 
                 (1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1  

// Arrays to store Yearly and Monthly P&Ls
var month_pnl  = array.new_float(0)
var month_time = array.new_int(0)

var year_pnl  = array.new_float(0)
var year_time = array.new_int(0)

if (not na(cur_month_pnl[1]) and (new_month or barstate.islast))
    array.push(month_pnl , cur_month_pnl[1])
    array.push(month_time, time[1])

if (not na(cur_year_pnl[1]) and (new_year or barstate.islast))
    array.push(year_pnl , cur_year_pnl[1])
    array.push(year_time, time[1])

// Monthly P&L Table    
var monthly_table = table(na)

if (barstate.islast)
    monthly_table := table.new(position.bottom_right, columns = 14, rows = array.size(year_pnl) + 1, border_width = 1)

    table.cell(monthly_table, 0,  0, "",     bgcolor = #cccccc)
    table.cell(monthly_table, 1,  0, "Jan",  bgcolor = #cccccc)
    table.cell(monthly_table, 2,  0, "Feb",  bgcolor = #cccccc)
    table.cell(monthly_table, 3,  0, "Mar",  bgcolor = #cccccc)
    table.cell(monthly_table, 4,  0, "Apr",  bgcolor = #cccccc)
    table.cell(monthly_table, 5,  0, "May",  bgcolor = #cccccc)
    table.cell(monthly_table, 6,  0, "Jun",  bgcolor = #cccccc)
    table.cell(monthly_table, 7,  0, "Jul",  bgcolor = #cccccc)
    table.cell(monthly_table, 8,  0, "Aug",  bgcolor = #cccccc)
    table.cell(monthly_table, 9,  0, "Sep",  bgcolor = #cccccc)
    table.cell(monthly_table, 10, 0, "Oct",  bgcolor = #cccccc)
    table.cell(monthly_table, 11, 0, "Nov",  bgcolor = #cccccc)
    table.cell(monthly_table, 12, 0, "Dec",  bgcolor = #cccccc)
    table.cell(monthly_table, 13, 0, "Year", bgcolor = #999999)


    for yi = 0 to array.size(year_pnl) - 1
        table.cell(monthly_table, 0,  yi + 1, str.tostring(year(array.get(year_time, yi))), bgcolor = #cccccc)
        
        y_color = array.get(year_pnl, yi) > 0 ? color.new(color.green, transp = 50) : color.new(color.red, transp = 50)
        table.cell(monthly_table, 13, yi + 1, str.tostring(math.round(array.get(year_pnl, yi) * 100, prec)), bgcolor = y_color)
        
    for mi = 0 to array.size(month_time) - 1
        m_row   = year(array.get(month_time, mi))  - year(array.get(year_time, 0)) + 1
        m_col   = month(array.get(month_time, mi)) 
        m_color = array.get(month_pnl, mi) > 0 ? color.new(color.green, transp = 70) : color.new(color.red, transp = 70)
        
        table.cell(monthly_table, m_col, m_row, str.tostring(math.round(array.get(month_pnl, mi) * 100, prec)), bgcolor = m_color)