Strategi perdagangan RSI tertunda menggunakan penunjuk RSI konvensional untuk mengenal pasti keadaan overbought dan oversold, dan penundaan memasuki pasaran untuk tempoh tertentu selepas isyarat muncul untuk mengelakkan kerugian yang tidak perlu daripada pecah palsu.
Strategi ini menggunakan penunjuk RSI 21 tempoh untuk menentukan keadaan overbought dan oversold. Apabila penunjuk RSI melintasi di atas tahap overbought yang ditakrifkan oleh pengguna (default 60), pasaran dianggap overbought. Apabila RSI melintasi di bawah tahap oversold yang ditakrifkan oleh pengguna (default 40), pasaran dianggap oversold.
Selepas mengenal pasti isyarat overbought atau oversold, strategi ini tidak memasuki pasaran dengan segera. Sebaliknya, ia mula mengira tempoh kelewatan. Apabila tempoh kelewatan (default 15 bar) dipenuhi, ia masuk pendek berdasarkan isyarat overbought, dan panjang berdasarkan isyarat oversold.
Strategi ini membolehkan pengguna menyesuaikan tempoh kelewatan untuk mencapai masa kemasukan yang berbeza. Tempoh kelewatan yang lebih lama dapat mengelakkan lebih banyak breakout palsu, tetapi juga mungkin kehilangan peluang kemasukan yang lebih baik. Pengguna perlu menyesuaikan parameter tempoh kelewatan berdasarkan ciri-ciri produk tertentu.
Di samping itu, strategi ini juga melaksanakan pilihan seperti stop loss, mengambil keuntungan, perdagangan terbalik, dan lain-lain. Pengguna boleh memilih stop loss tetap, trailing stop loss, fixed take profit dan sebagainya untuk menguruskan kedudukan. Logik perdagangan juga boleh terbalik, iaitu pergi panjang pada isyarat overbought dan pendek pada isyarat oversold.
Menggunakan penunjuk RSI untuk mengenal pasti keadaan overbought / oversold dengan tepat dan menangkap peluang pembalikan.
Penutupan penutupan mengelakkan kerugian daripada pelarian palsu. Banyak pelarian tidak semestinya membawa kepada pembalikan sebenar. Penutupan penutupan mengesahkan kesahihan.
Tempoh kelewatan yang boleh disesuaikan membolehkan masa kemasukan yang tepat. Pengguna boleh mengoptimumkan tempoh kelewatan berdasarkan ciri produk untuk kemasukan yang terbaik.
Melaksanakan stop loss dan mengambil keuntungan untuk mengawal risiko. Strategi ini menawarkan pelbagai cara seperti SL / TP tetap, SL menyusul dan lain-lain untuk menguruskan risiko.
Pilihan perdagangan terbalik menyesuaikan diri dengan produk yang berbeza. Pengguna boleh memilih logik normal atau terbalik untuk lindung nilai ketidakpastian.
Risiko isyarat palsu dari RSI Isyarat RSI mungkin tidak selalu tepat dan kadang-kadang boleh memberikan isyarat palsu.
Risiko kehilangan peluang jika kelewatan terlalu lama.
Peningkatan risiko kerugian daripada perdagangan terbalik Walaupun perdagangan terbalik lindung nilai ketidakpastian, ia juga boleh memperkuat kerugian keseluruhan.
Risiko mengikuti SL terlalu dekat dan dihentikan terlalu awal.
Keuntungan yang tidak mencukupi kerana TP tetap yang tidak tepat. TP tetap tidak dapat mencapai keuntungan maksimum dan memerlukan ramalan yang munasabah.
Untuk menangani risiko ini, cadangan pengoptimuman adalah:
Menapis isyarat RSI dengan penunjuk lain seperti KDJ, MACD dan lain-lain untuk meningkatkan kebolehpercayaan.
Backtest dengan data sejarah untuk mencari tempoh tempoh yang optimum untuk setiap produk.
Gunakan logik terbalik dengan berhati-hati, lebih baik digabungkan dengan trend berikut.
Simpan penyangga yang luas untuk menyusul SL untuk mengelakkan harga terlalu dekat.
Uji nisbah TP yang berbeza untuk mencari yang optimum.
Strategi ini boleh dioptimumkan lagi dalam aspek berikut:
Gabungkan beberapa penunjuk untuk menapis isyarat kemasukan, contohnya KDJ, MACD dengan RSI untuk isyarat yang lebih kukuh.
Dinamis menyesuaikan tempoh kelewatan berdasarkan turun naik pasaran. Ini mengekalkan mengelakkan pecah palsu sambil meningkatkan ketepatan kemasukan.
Mengoptimumkan strategi SL/TP, seperti SL dinamik, nisbah pemulihan keuntungan SL, SL berasaskan masa dan lain-lain, menjadikannya lebih sesuai dengan perubahan pasaran.
Menggabungkan trend. Menentukan sama ada arah pecah sejajar dengan trend utama. Juga menyesuaikan tempoh kelewatan berdasarkan momentum pecah.
Menggunakan pembelajaran mesin untuk mencari kombinasi parameter yang optimum. ML boleh menyesuaikan parameter secara automatik berdasarkan kumpulan data latihan dan backtest yang besar.
Kesimpulannya, strategi ini mempunyai ruang yang luas untuk pengoptimuman melalui kombinasi penunjuk, penyesuaian dinamik parameter, integrasi trend dll. ML juga merupakan arah yang menjanjikan ke hadapan.
Strategi RSI tertunda secara keseluruhan menggunakan RSI untuk mengenal pasti keadaan overbought / oversold, dan kelewatan masuk untuk tempoh selepas isyarat berlaku untuk mengelakkan kerugian yang tidak perlu daripada penipuan. Strategi ini mempunyai kelebihan seperti pengenalan isyarat yang tepat, kelewatan masuk untuk mengelakkan pecah palsu, tempoh kelewatan yang boleh disesuaikan, pelaksanaan SL / TP dan lain-lain. Tetapi risiko seperti isyarat RSI yang tidak boleh dipercayai, peluang yang hilang dari kelewatan yang berlebihan wujud. Ini dapat ditingkatkan lagi dengan mengoptimumkan ketepatan isyarat melalui kombinasi penunjuk, penyesuaian tempoh kelewatan dinamik, strategi SL / TP yang lebih baik dan lain-lain. Strategi ini mempunyai peluang pengoptimuman yang luas dan patut diterokai.
/*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)