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

आरएसआई ट्रेंड ट्रेलिंग स्टॉप लॉस के साथ रणनीति का पालन करना

लेखक:चाओझांग, दिनांकः 2023-12-08 11:41:31
टैगः

img

अवलोकन

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

रणनीति तर्क

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

लंबा संकेतः आरएसआई 68 से ऊपर जाता है और वर्तमान चलती औसत पिछले चलती औसत से ऊपर जाता है, लंबा जाता है।
शॉर्ट सिग्नलः आरएसआई 28 से नीचे जाता है और वर्तमान चलती औसत पिछले चलती औसत से नीचे जाता है, शॉर्ट हो जाता है।

स्टॉप लॉस और टेक प्रॉफिट सेटिंग्स अधिक ढीली से लेकर अधिक सख्त तक हैं:

दीर्घ लाभः उच्च से 1.4% ऊपर स्थित स्थिति का 50% लाभ लें, उच्च से 0.8% ऊपर स्थित स्थिति से 100% लाभ लें।
लॉन्ग स्टॉप लॉसः स्टॉप लॉस को प्रवेश मूल्य से 2% नीचे सेट करें।

शॉर्ट टेक प्रॉफिटः 0.4% कम से 0.8% कम पर 50% प्रॉफिट लें, 0.8% कम से 100% प्रॉफिट लें। शॉर्ट स्टॉप लॉसः प्रवेश मूल्य से 2% ऊपर स्टॉप लॉस सेट करें।

इसके अलावा, जब रुझान उलट जाता है, जैसे कि आरएसआई 30 से नीचे टूट जाता है जब लंबा होता है, तो बाजार पर पूरी लंबी स्थिति बंद कर देता है; जब आरएसआई 60 से ऊपर टूट जाता है जब छोटा होता है, तो बाजार पर पूरी छोटी स्थिति बंद कर देता है।

लाभ

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

जोखिम

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

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

बढ़ोतरी के अवसर

इस रणनीति में और सुधार किया जा सकता हैः

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

निष्कर्ष

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


// © 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)      


अधिक