Strategi perdagangan RSI tertunda menggunakan indikator RSI konvensional untuk mengidentifikasi kondisi overbought dan oversold, dan penundaan memasuki pasar untuk periode tertentu setelah sinyal muncul untuk menghindari kerugian yang tidak perlu dari breakout palsu.
Strategi ini menggunakan indikator RSI 21 periode untuk menentukan kondisi overbought dan oversold. Ketika indikator RSI melintasi di atas level overbought yang ditentukan pengguna (default 60), pasar dianggap overbought. Ketika RSI melintasi di bawah level overbought yang ditentukan pengguna (default 40), pasar dianggap oversold.
Setelah mengidentifikasi sinyal overbought atau oversold, strategi tidak masuk ke pasar segera. Sebaliknya, strategi mulai menghitung periode keterlambatan. Ketika periode keterlambatan (default 15 bar) terpenuhi, strategi masuk pendek berdasarkan sinyal overbought, dan panjang berdasarkan sinyal oversold.
Strategi ini memungkinkan pengguna untuk menyesuaikan periode penundaan untuk mencapai waktu masuk yang berbeda. Periode penundaan yang lebih lama dapat menghindari lebih banyak breakout palsu, tetapi juga dapat kehilangan peluang masuk yang lebih baik. Pengguna perlu menyesuaikan parameter periode penundaan berdasarkan karakteristik produk tertentu.
Selain itu, strategi ini juga menerapkan opsi seperti stop loss, take profit, reverse trading, dll. Pengguna dapat memilih fixed stop loss, trailing stop loss, fixed take profit dan sebagainya untuk mengelola posisi.
Menggunakan indikator RSI untuk mengidentifikasi kondisi overbought / oversold dengan akurat dan menangkap peluang pembalikan.
Penundaan masuk menghindari kerugian dari breakout palsu. Banyak breakout tidak selalu mengarah pada pembalikan nyata. Penundaan masuk memverifikasi keabsahannya.
Periode penundaan yang dapat disesuaikan memungkinkan waktu entri yang akurat. Pengguna dapat mengoptimalkan periode penundaan berdasarkan karakteristik produk untuk entri terbaik.
Mengimplementasikan stop loss dan mengambil keuntungan untuk mengendalikan risiko. Strategi ini menawarkan beberapa cara seperti SL / TP tetap, SL trailing dll untuk mengelola risiko.
Pengguna dapat memilih logika normal atau terbalik untuk lindung nilai ketidakpastian.
Risiko sinyal palsu dari RSI. Sinyal RSI mungkin tidak selalu akurat dan kadang-kadang dapat memberikan sinyal palsu.
Risiko kehilangan kesempatan jika keterlambatan terlalu lama.
Meningkatnya risiko kerugian dari reverse trading Meskipun reverse trading lindungi ketidakpastian, hal ini juga dapat memperkuat total kerugian.
Risiko mengikuti SL terlalu dekat dan berhenti terlalu dini.
Keuntungan yang tidak cukup karena TP tetap yang tidak akurat. TP tetap tidak dapat mencapai keuntungan maksimum dan membutuhkan perkiraan yang wajar.
Untuk mengatasi risiko ini, saran optimasi adalah:
Filter sinyal RSI dengan indikator lain seperti KDJ, MACD dll untuk meningkatkan keandalan.
Backtest dengan data historis untuk menemukan periode penundaan optimal untuk setiap produk.
Gunakan logika terbalik dengan hati-hati, sebaiknya digabungkan dengan mengikuti tren.
Simpan buffer yang luas untuk SL yang tertinggal untuk menghindari harga yang terlalu dekat.
Uji rasio TP yang berbeda untuk menemukan yang optimal. Pertimbangkan mengambil keuntungan dinamis juga.
Strategi ini dapat dioptimalkan lebih lanjut dalam aspek berikut:
Menggabungkan beberapa indikator untuk menyaring sinyal masuk, misalnya KDJ, MACD dengan RSI untuk sinyal yang lebih kuat.
Dinamis menyesuaikan periode keterlambatan berdasarkan volatilitas pasar. Ini mempertahankan menghindari false breakout sambil meningkatkan akurasi entri.
Mengoptimalkan strategi SL/TP, seperti SL dinamis, rasio retracement laba SL, SL berbasis waktu dll, membuat mereka lebih beradaptasi dengan perubahan pasar.
Menggabungkan tren. Mengukur apakah arah breakout sejajar dengan tren utama. Juga menyesuaikan periode penundaan berdasarkan momentum breakout.
Menggunakan pembelajaran mesin untuk menemukan kombinasi parameter yang optimal. ML dapat menyesuaikan parameter secara otomatis berdasarkan pelatihan dan backtest dataset besar.
Kesimpulannya, strategi ini memiliki ruang yang cukup untuk optimalisasi melalui kombinasi indikator, penyesuaian dinamis parameter, integrasi tren dll. ML juga merupakan arah yang menjanjikan ke depan.
Strategi RSI tertunda secara keseluruhan menggunakan RSI untuk mengidentifikasi kondisi overbought/oversold, dan penundaan masuk untuk periode setelah sinyal terjadi untuk menghindari kerugian yang tidak perlu dari penipuan. Strategi ini memiliki keuntungan seperti identifikasi sinyal yang akurat, penundaan masuk untuk menghindari pemutusan palsu, periode penundaan yang dapat disesuaikan, implementasi SL/TP dll. Tetapi risiko seperti sinyal RSI yang tidak dapat diandalkan, kesempatan yang hilang dari keterlambatan yang berlebihan ada. Ini dapat ditingkatkan lebih lanjut dengan mengoptimalkan akurasi sinyal melalui kombinasi indikator, penyetelan periode penundaan dinamis, strategi SL/TP yang lebih baik dll. Strategi ini memiliki peluang optimasi yang luas dan layak dijelajahi.
/*backtest
start: 2023-01-01 00:00:00
end: 2023-10-06 00:00:00
period: 1d
basePeriod: 1h
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/
// © tweakerID and © BacktestRookies
// This strategy uses a 21 period RSI with an overbought (RSI indicator
// is greater than) level of 60 (user defined) to determines long entries and an oversold
// (RSI indicator is less than) level of 40 (user defined) for shorts. It introduces a bar delay that starts
// counting when the RSI < Oversold or RSI > Overbought conditions are true, delaying the entry with
// the amount of bars determined by the user. The trading logic can be reversed, which seems to work better.
//@version=4
strategy("Delayed RSI Strategy",
overlay=false,
default_qty_type=strategy.percent_of_equity,
default_qty_value=100,
initial_capital=10000,
commission_value=0.04,
calc_on_every_tick=false,
slippage=0)
direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all :
(direction < 0 ? strategy.direction.short : strategy.direction.long))
// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1]
or strategy.position_size < strategy.position_size[1]
/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")
rsiLen=input(21, title="RSI Length")
i_OB = input(60, title="Overbought")
i_OS = input(40, title="Oversold")
i_delay = input(15, title="Entry Delay (# of Bars)")
i_Close= input(false, title="Use Strategy Close")
/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")
// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
TS=input(false, title="Use Trailing Stop")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(3, step=.1, title="ATR Multiple")
i_TPRRR = input(2, step=.1, title="Take Profit Risk Reward Ratio")
DPR=input(false, "Allow Direct Position Reverse")
reverse=input(true, "Reverse Trades")
// Swing Points Stop and Take Profit
SwingStopProfit() =>
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na
entry_HH_price = strategy.position_size < 0 ? HH_price : na
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR
[entry_LL_price, entry_HH_price, tp, stp]
// ATR Stop
ATRStop() =>
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR
[LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp]
// Strategy Stop
StrategyStop(bought) =>
float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na
[LongStop, ShortStop, StratTP, StratSTP]
//TrailingStop
TrailingStop(SL,SSL) =>
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
-strategy.position_avg_price
trailOffset = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
tstop := high- trailOffset - dif
if tstop<tstop[1]
tstop:=tstop[1]
else
tstop := na
StrailOffset = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0
and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
Ststop := low+ StrailOffset + Sdif
if Ststop>Ststop[1]
Ststop:=Ststop[1]
else
Ststop := na
[tstop, Ststop]
//Stop Loss & Take Profit Switches
SLTPLogic(LongStop, ShortStop, StratTP, StratSTP, LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp,
entry_LL_price, entry_HH_price, tp, stp) =>
SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP
[SL, SSL, TP, STP]
/////////////////////// STRATEGY LOGIC /////////////////////////////////////////
rsi = rsi(close, rsiLen)
isOB= rsi > i_OB
isOS= rsi < i_OS
BarsSinceOB = barssince(not isOB)
BarsSinceOS = barssince(not isOS)
BUY = BarsSinceOS == i_delay
SELL = BarsSinceOB == i_delay
/////////////////////// FUNCTION CALLS /////////////////////////////////////////
// Stops and Profits
[entry_LL_price, entry_HH_price, tp, stp] = SwingStopProfit()
[LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp] = ATRStop()
[LongStop, ShortStop, StratTP, StratSTP] = StrategyStop(bought)
[SL, SSL, TP, STP] = SLTPLogic(LongStop, ShortStop, StratTP, StratSTP,
LongSL_ATR_price, ShortSL_ATR_price, ATRtp, ATRstp, entry_LL_price, entry_HH_price, tp, stp)
[tstop, Ststop] = TrailingStop(SL,SSL)
// Entries
if reverse
if not DPR
strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=SELL)
strategy.entry("short", strategy.short, when=BUY)
else
if not DPR
strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=BUY)
strategy.entry("short", strategy.short, when=SELL)
// Exits
if i_SL
strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL)
if i_Close
strategy.close_all(when=cross(rsi, 50))
/////////////////////// PLOTS //////////////////////////////////////////////////
//Plots
rsiplot = plot(rsi, "RSI", color=#7E57C2)
band1 = hline(i_OB, "Upper Band", color=#787B86)
bandm = hline(50, "Middle Band", color=color.new(#787B86, 50))
band0 = hline(i_OS, "Lower Band", color=#787B86)
fill(band1, band0, color=color.rgb(126, 87, 194, 90), title="Background")
plot(rsi, "RSI", color=#7E57C2)
// OSOBCount = plot(isOB ? BarsSinceOB : isOS ? BarsSinceOS : na, transp=100)
// OSOBColor = color.from_gradient(isOB ? BarsSinceOB : BarsSinceOS, 0, 20, color.black, isOB ? color.red : isOS ? color.green : na)
// OBP = plot(rsi > i_OB ? rsi : na, color=color.white, display=display.none)
// fill(plot(i_OB, display=display.none), OBP, color=OSOBColor, transp=0, fillgaps=false)
// OSP = plot(rsi < i_OS ? rsi : na, color=color.white, display=display.none)
// fill(plot(i_OS, display=display.none), OSP, color=OSOBColor, transp=0, fillgaps=false)
// plotshape(BUY ? 1 : na, style=shape.arrowdown, location=location.bottom,
// color=color.green, title="Bullish Setup", size=size.normal)
// plotshape(SELL ? 1 : na, style=shape.arrowup, location=location.top,
// color=color.red, title="Bearish Setup", size=size.normal)