Strategi Perdagangan RSI Tertunda
ChaoZhang
Ringkasan
Strategi perdagangan RSI yang tertunda menggunakan indikator RSI konvensional untuk mengidentifikasi overbought dan oversold, dan menunda masuknya setelah munculnya sinyal masuk untuk menghindari kerugian yang tidak perlu akibat terobosan palsu. Gagasan utama strategi ini adalah menggunakan indikator RSI untuk menilai fenomena overbought dan oversold di pasar, dan berdasarkan penilaian ini, untuk menangkap waktu masuk yang lebih akurat dengan menunda masuknya.
Prinsip Strategi
Strategi ini menggunakan indikator RSI dengan panjang 21 siklus untuk menilai overbought dan oversold. Ketika indikator RSI melewati batas overbought yang ditetapkan pengguna (default 60), dianggap sebagai overbought; Ketika indikator RSI di bawah melewati batas oversold yang ditetapkan pengguna (default 40), dianggap sebagai oversold.
Strategi tidak akan langsung masuk setelah sinyal overbought dan oversold muncul, tetapi mulai menghitung periode penundaan. Ketika jumlah periode penundaan (default 15 cycle) terpenuhi, kemudian sesuai dengan sinyal overbought kosong, sinyal oversold lebih banyak.
Strategi ini memungkinkan pengguna untuk menyesuaikan jumlah siklus penundaan, untuk mencapai waktu masuk yang berbeda. Periode penundaan yang lebih lama dapat menghindari lebih banyak penembusan palsu, tetapi juga mungkin kehilangan titik masuk yang lebih baik. Pengguna perlu menyesuaikan parameter siklus penundaan sesuai dengan varietas tertentu.
Selain itu, strategi ini juga mengimplementasikan opsi seperti stop loss, stop loss, dan reverse trading. Pengguna dapat memilih untuk mengelola posisi dengan cara seperti stop loss tetap, tracking stop loss, dan stop loss tetap.
Keunggulan Strategis
Dengan menggunakan indikator RSI untuk menilai overbought dan oversold, peluang reversal dapat ditangkap dengan akurat. RSI adalah indikator overbought dan oversold yang lebih matang, yang dapat secara efektif mengidentifikasi peluang reversal.
Mekanisme penundaan masuk dapat mencegah terjadinya kerugian akibat terobosan palsu. Banyak terobosan yang tidak selalu merupakan pembalikan substansial, penundaan masuk dapat memverifikasi keabsahan terobosan tersebut.
Dapat disesuaikan dengan jumlah siklus penundaan, untuk mengetahui waktu masuk yang tepat. Pengguna dapat menyesuaikan siklus penundaan sesuai dengan karakteristik varietas yang berbeda, untuk mencapai titik masuk yang optimal.
Menerapkan Stop Loss, Manajemen Stop Loss, dan Mengontrol Risiko. Strategi menyediakan berbagai cara untuk menghentikan dan menghentikan kerugian, yang dapat dikombinasikan dengan keterlambatan masuk ke dalam permainan untuk mengendalikan risiko.
Memberikan opsi perdagangan terbalik, menyesuaikan dengan karakteristik varietas yang berbeda. Pengguna dapat memilih logika perdagangan positif atau terbalik untuk melindungi ketidakpastian.
Risiko Strategis
Risiko RSI mengirimkan sinyal palsu. Sinyal RSI tidak selalu efektif, dan dalam beberapa situasi pasar dapat terjadi sinyal yang salah.
Terlalu banyak penundaan berisiko kehilangan waktu masuk. Terlalu banyak penundaan dapat menyebabkan kehilangan titik masuk.
Perdagangan reverse meningkatkan risiko kerugian. Meskipun perdagangan reverse dapat melindungi dari ketidakpastian, tetapi juga dapat memperluas kerugian keseluruhan.
Tracking stop loss adalah risiko yang ditargetkan. Tracking stop loss mungkin terlalu dekat dengan harga saat ini ketika harga berubah secara drastis, dan harga akan terjatuh.
Stop loss estimasi tidak dapat menyebabkan keuntungan yang tidak cukup. Stop loss tetap tidak dapat mencapai keuntungan maksimum, perlu estimasi yang masuk akal untuk mengatur.
Untuk mengatasi risiko tersebut, berikut adalah rekomendasi pengoptimalan:
Dalam kombinasi dengan indikator lain yang memfilter sinyal RSI, meningkatkan reliabilitas. Indikator seperti KDJ, MACD dll.
Parameter siklus latensi yang optimal diambil berdasarkan data historis dari berbagai varietas.
Berhati-hatilah dalam menggunakan fitur trading reverse, sebaiknya dengan cara yang menggabungkan trend trading dan lainnya.
Saat melacak stop loss, atur jarak yang lebih lebar untuk menghindari terlalu dekat dengan harga saat ini.
Uji berbagai stop-loss multiplier untuk menemukan parameter optimal. Anda juga dapat mempertimbangkan stop-loss dinamis.
Arah optimasi
Strategi ini dapat dioptimalkan lebih lanjut dalam beberapa hal:
Kombinasi berbagai indikator yang memfilter sinyal masuk. Indikator seperti KDJ, MACD dan lain-lain yang dikombinasikan dengan RSI, dapat membentuk sinyal perdagangan yang lebih andal.
Dinamis menyesuaikan siklus penundaan. Anda dapat secara dinamis mengubah siklus penundaan sesuai dengan tingkat fluktuasi pasar, dan Anda dapat meningkatkan akurasi masuk dengan memastikan bahwa Anda tidak melakukan false breakout.
Optimalkan strategi stop loss. Anda dapat mempelajari stop loss dinamis, stop loss rasio pengembalian keuntungan, dan stop loss waktu, sehingga stop loss lebih sesuai dengan karakteristik fluktuasi pasar.
Kombinasi faktor tren. Anda dapat menilai kesesuaian arah terobosan dengan arah tren besar, menghindari perdagangan berlawanan. Anda juga dapat menyesuaikan jumlah siklus keterlambatan sesuai dengan kekuatan terobosan.
Menggunakan pembelajaran mesin untuk menemukan kombinasi parameter yang optimal. Dengan banyak latihan dan pengulangan data, pembelajaran mesin dapat secara otomatis menyesuaikan parameter untuk mendapatkan kombinasi parameter yang optimal.
Secara keseluruhan, strategi ini masih memiliki banyak ruang untuk dioptimalkan, dan dapat dibuat lebih stabil dan dapat diandalkan melalui kombinasi indikator, dinamika, dan penilaian tren. Penggunaan pembelajaran mesin juga merupakan arah optimasi yang diharapkan di masa depan.
Meringkaskan
Strategi RSI yang ditunda secara keseluruhan Menggunakan indikator RSI untuk menilai overbought dan oversold, dan menunda masuk kembali setelah munculnya sinyal, dapat secara efektif mencegah penipuan palsu yang menyebabkan kerugian yang tidak perlu. Strategi ini memiliki keunggulan seperti akurasi penentuan indikator, penundaan masuk untuk menghindari penipuan palsu, dapat menyesuaikan siklus penundaan, dan mengelola stop loss. Namun, ada juga risiko RSI yang tidak dapat diandalkan, terlalu banyak penundaan, kehilangan kesempatan.
/*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)