Strategi Dagangan RSI Tertunda
ChaoZhang
Gambaran keseluruhan
Strategi perdagangan RSI yang ditangguhkan menggunakan penunjuk RSI biasa untuk mengenal pasti keadaan overbought dan oversold, dan menunda masuk ke dalam pasaran setelah munculnya isyarat masuk untuk mengelakkan kerugian yang tidak perlu disebabkan oleh pecah palsu. Gagasan utama strategi ini adalah menggunakan indikator RSI untuk menilai fenomena overbought dan oversold di pasaran, berdasarkan penilaian ini, untuk mendapatkan peluang masuk yang lebih tepat dengan menangguhkan masuk ke dalam pasaran.
Prinsip Strategi
Strategi ini menggunakan indikator RSI dengan panjang 21 kitaran untuk menilai keadaan overbought dan oversold. Apabila indikator RSI melintasi garis overbought yang ditetapkan oleh pengguna (default 60), dianggap sebagai overbought; apabila indikator RSI di bawah melintasi garis oversold yang ditetapkan oleh pengguna (default 40), dianggap sebagai oversold.
Setelah melihat bahawa isyarat overbought dan oversold muncul, strategi tidak akan masuk ke dalam permainan dengan serta-merta, tetapi mula mengira kitaran kelewatan. Apabila jumlah kitaran kelewatan (default 15 kitaran) dipenuhi, kemudian ikut isyarat overbought dan oversold, lakukan lebih banyak.
Strategi ini membolehkan pengguna menyesuaikan bilangan kitaran kelewatan untuk mencapai masa masuk yang berbeza. Semakin lama kitaran kelewatan, lebih banyak penembusan palsu dapat dielakkan, tetapi juga mungkin kehilangan titik masuk yang lebih baik. Pengguna perlu menyesuaikan parameter kitaran kelewatan mengikut jenis tertentu.
Selain itu, strategi ini juga mewujudkan pilihan seperti berhenti, berhenti, dan perdagangan terbalik. Pengguna boleh memilih untuk menguruskan kedudukan mereka dengan cara berhenti tetap, mengesan berhenti, dan berhenti tetap.
Kelebihan Strategik
Menggunakan RSI untuk menilai keadaan overbought dan oversold, anda dapat dengan tepat menangkap peluang untuk berbalik. RSI adalah indikator overbought dan oversold yang lebih matang, yang dapat mengenal pasti peluang untuk berbalik.
Mekanisme kelewatan kemasukan dapat mengelakkan kerugian akibat penembusan palsu. Banyak penembusan tidak semestinya menunjukkan perubahan yang nyata, dan kelewatan kemasukan dapat mengesahkan kesahihan penembusan.
Boleh menyesuaikan bilangan kitaran kelewatan, untuk mengetahui masa masuk yang tepat. Pengguna boleh menyesuaikan kitaran kelewatan mengikut ciri-ciri varieti yang berbeza, untuk mencapai titik masuk yang terbaik.
Mempunyai pengurusan hentian, hentian, dan risiko yang boleh dikawal. Strategi menyediakan pelbagai cara hentian dan hentian yang boleh dikombinasikan dengan kelewatan kemasukan untuk mengawal risiko.
Memberi pilihan perdagangan terbalik, menyesuaikan diri dengan ciri-ciri varieti yang berbeza. Pengguna boleh memilih logik perdagangan positif atau terbalik untuk melindungi ketidakpastian.
Risiko Strategik
Risiko RSI menghantar isyarat palsu. Isyarat RSI tidak selalu berkesan, dan dalam keadaan pasaran tertentu, isyarat salah boleh berlaku.
Penangguhan terlalu banyak berisiko kehilangan masa kemasukan. Penetapan kitaran kelewatan terlalu lama boleh menyebabkan kehilangan tempat kemasukan yang lebih baik.
Perdagangan terbalik meningkatkan risiko kerugian. Walaupun perdagangan terbalik melindungi ketidakpastian, ia juga boleh meningkatkan kerugian keseluruhan.
Tracking stop loss terhad kepada risiko terhad. Tracking stop loss mungkin terlalu dekat dengan harga semasa apabila harga berubah secara mendadak dan terhad kepada risiko terhad.
Penangguhan yang diramalkan tidak boleh menyebabkan keuntungan yang tidak mencukupi. Penangguhan tetap tidak dapat mencapai keuntungan maksimum dan memerlukan anggaran yang munasabah untuk ditetapkan.
Nasihat untuk pengoptimuman terhadap risiko di atas adalah seperti berikut:
Gabungan dengan petunjuk lain untuk menapis isyarat RSI, meningkatkan kebolehpercayaan. Indikator seperti KDJ, MACD dan sebagainya.
Parameter kitaran kelewatan yang optimum diambil berdasarkan ujian data sejarah pelbagai jenis. Ia tidak boleh diringkaskan.
Berhati-hati menggunakan fungsi dagangan terbalik, sebaiknya digabungkan dengan perdagangan trend dan sebagainya.
Tetapkan jarak yang lebih luas untuk menjejaki stop loss, dan elakkan terlalu dekat dengan harga semasa.
Uji perkalian hentian yang berbeza untuk mencari parameter optimum. Anda juga boleh mempertimbangkan hentian dinamik.
Arah pengoptimuman
Strategi ini boleh dioptimumkan dengan cara berikut:
Gabungan pelbagai petunjuk penapis isyarat masuk. Indikator seperti KDJ, MACD dan lain-lain yang digabungkan dengan RSI dapat membentuk isyarat perdagangan yang lebih dipercayai.
Dinamik menyesuaikan bilangan kitaran penangguhan. Anda boleh mengubah bilangan kitaran penangguhan secara dinamik mengikut tahap turun naik pasaran, dan anda juga boleh meningkatkan ketepatan kemasukan dengan memastikan anda tidak melakukan penembusan palsu.
Mengoptimumkan strategi hentian kerugian. Anda boleh mengkaji hentian dinamik, hentian kadar penarikan keuntungan, hentian masa, dan lain-lain, sehingga hentian kerugian lebih sesuai dengan ciri-ciri turun naik pasaran.
Dengan menggabungkan faktor trend, anda boleh menilai kesesuaian arah penembusan dengan arah trend besar, dan mengelakkan perdagangan berlawanan. Anda juga boleh menyesuaikan bilangan kitaran kelewatan mengikut kekuatan penembusan.
Menggunakan pembelajaran mesin untuk mencari kombinasi parameter yang optimum. Dengan banyak latihan dan data pengulangan, pembelajaran mesin dapat menyesuaikan parameter secara automatik untuk mendapatkan kombinasi parameter yang optimum.
Secara keseluruhannya, terdapat banyak ruang untuk pengoptimuman strategi ini, yang dapat menjadikan strategi ini lebih stabil dan boleh dipercayai melalui kombinasi penunjuk, penyelarasan dinamik, dan penilaian trend. Penggunaan pembelajaran mesin juga merupakan arah pengoptimuman yang diharapkan pada masa akan datang.
ringkaskan
Strategi RSI yang ditangguhkan secara keseluruhan Menggunakan indikator RSI untuk menilai keadaan overbought dan oversold, dan menangguhkan satu kitaran masuk semula selepas isyarat muncul, dapat menghalang penembusan palsu yang tidak perlu. Strategi ini mempunyai kelebihan seperti ketepatan penentuan indikator, menangguhkan masuk untuk mengelakkan penembusan palsu, dapat menyesuaikan kitaran penembusan, dan mencapai pengurusan berhenti berhenti. Tetapi ada juga risiko RSI. Isyarat tidak boleh dipercayai, kelewatan terlalu banyak kehilangan peluang.
/*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)