Chiến lược giao dịch RSI bị trì hoãn
ChaoZhang
Tổng quan
Chiến lược giao dịch trì hoãn RSI sử dụng chỉ số RSI thông thường để xác định trường hợp quá mua quá bán và trì hoãn nhập cảnh sau một khoảng thời gian nhất định sau khi có tín hiệu nhập cảnh để tránh tổn thất không cần thiết do phá vỡ giả. Ý tưởng chính của chiến lược này là sử dụng chỉ số RSI để đánh giá hiện tượng mua quá bán của thị trường và dựa trên phán đoán này, bằng cách trì hoãn nhập cảnh để nắm bắt thời gian nhập cảnh chính xác hơn.
Nguyên tắc chiến lược
Chiến lược này sử dụng chỉ số RSI với độ dài 21 chu kỳ để đánh giá tình trạng quá mua quá bán. Khi chỉ số RSI vượt qua đường mua quá mức đặt của người dùng (bằng mặc định 60), nó được coi là quá mua; Khi chỉ số RSI vượt qua đường bán quá mức đặt của người dùng (bằng mặc định 40), nó được coi là quá bán.
Sau khi đánh giá tín hiệu mua quá mức xuất hiện, chiến lược sẽ không ngay lập tức tham gia, mà sẽ bắt đầu tính toán chu kỳ trì hoãn. Khi số chu kỳ trì hoãn (chỉ số 15 chu kỳ mặc định) được đáp ứng, sau đó theo tín hiệu mua quá mức, làm trống, tín hiệu bán quá mức.
Chiến lược này cho phép người dùng điều chỉnh số lượng chu kỳ trì hoãn để thực hiện thời gian nhập cảnh khác nhau. Chu kỳ trì hoãn càng dài, sẽ tránh được nhiều đột phá giả, nhưng cũng có thể bỏ lỡ điểm nhập cảnh tốt hơn. Người dùng cần điều chỉnh tham số chu kỳ trì hoãn theo giống cụ thể.
Ngoài ra, chiến lược này cũng thực hiện các tùy chọn như dừng lỗ, dừng, giao dịch ngược. Người dùng có thể chọn cách quản lý vị trí bằng cách cố định dừng lỗ, theo dõi dừng lỗ, dừng cố định.
Lợi thế chiến lược
Sử dụng chỉ số RSI để đánh giá tình trạng quá mua quá bán, bạn có thể nắm bắt chính xác cơ hội đảo ngược. RSI là một chỉ số quá mua quá bán có độ trưởng thành hơn, có thể xác định hiệu quả cơ hội đảo ngược.
Cơ chế trì hoãn nhập cảnh có thể tránh các đột phá giả tạo gây ra tổn thất. Nhiều đột phá không nhất thiết phải là sự đảo ngược có tính chất, và trì hoãn nhập cảnh có thể xác minh tính hiệu quả của đột phá.
Có thể điều chỉnh số lần trì hoãn, nắm bắt chính xác thời gian vào cửa. Người dùng có thể điều chỉnh chu kỳ trì hoãn theo đặc điểm của các giống khác nhau để đạt được điểm vào cửa tối ưu.
Thực hiện dừng lỗ, quản lý dừng lỗ, kiểm soát rủi ro. Chiến lược cung cấp nhiều cách dừng lỗ, có thể phối hợp với việc trì hoãn nhập cảnh để kiểm soát rủi ro.
Cung cấp các tùy chọn giao dịch ngược, thích ứng với các đặc điểm khác nhau của giống. Người dùng có thể chọn logic giao dịch thẳng hoặc ngược để bảo vệ sự không chắc chắn.
Rủi ro chiến lược
RSI có nguy cơ phát ra tín hiệu sai. RSI không phải lúc nào cũng hiệu quả, và trong một số trường hợp thị trường, tín hiệu sai có thể xuất hiện.
Lãng trễ quá nhiều có nguy cơ bỏ lỡ thời gian vào cửa.
Giao dịch ngược làm tăng rủi ro thua lỗ. Giao dịch ngược có thể làm tăng tổng thua lỗ, mặc dù nó có thể bảo vệ sự không chắc chắn.
Tracking stop loss được đặt vào rủi ro. Tracking stop loss có thể bị phá vỡ khi giá thay đổi mạnh, nó có thể quá gần với giá hiện tại.
Dự đoán dừng không thể gây ra lợi nhuận không đủ. Đặt dừng không thể đạt được lợi nhuận tối đa, cần thiết phải có dự đoán hợp lý để thiết lập.
Các đề xuất tối ưu hóa đối với các rủi ro trên là:
Kết hợp với các chỉ số khác để lọc tín hiệu RSI, nâng cao độ tin cậy. Ví dụ: KDJ, MACD và các chỉ số khác.
Các tham số chu kỳ trì hoãn tối ưu dựa trên dữ liệu lịch sử của các giống khác nhau. Không nên nói chung.
Hãy cẩn thận khi sử dụng các tính năng giao dịch ngược, tốt nhất là kết hợp với các phương thức giao dịch theo xu hướng.
Đặt khoảng cách rộng hơn khi theo dõi lỗ hổng, tránh quá gần với giá hiện tại.
Thử nghiệm các số nhân ngắt khác nhau để tìm tham số tối ưu. Bạn cũng có thể xem xét ngắt động.
Hướng tối ưu hóa
Chiến lược này có thể được tối ưu hóa hơn nữa ở những khía cạnh sau:
Kết hợp nhiều chỉ số để lọc tín hiệu nhập cảnh. Ví dụ: KDJ, MACD và các chỉ số kết hợp với RSI, có thể tạo ra một tín hiệu giao dịch đáng tin cậy hơn.
Động thái điều chỉnh số lần trì hoãn. Có thể thay đổi số lần trì hoãn theo mức độ biến động của thị trường, đồng thời đảm bảo tránh phá vỡ giả, cũng có thể cải thiện độ chính xác nhập cảnh.
Tối ưu hóa chiến lược dừng lỗ. Bạn có thể nghiên cứu dừng động, dừng tỷ lệ thu hồi lợi nhuận, dừng thời gian, để dừng lỗ phù hợp hơn với đặc điểm biến động của thị trường.
Kết hợp các yếu tố xu hướng. Bạn có thể đánh giá sự phù hợp của hướng phá vỡ với hướng của xu hướng lớn, tránh giao dịch ngược. Bạn cũng có thể điều chỉnh số lần trì hoãn theo cường độ phá vỡ.
Sử dụng học máy để tìm các tham số tối ưu. Bằng cách đào tạo và phản hồi dữ liệu lớn, học máy có thể tự động điều chỉnh các tham số để có được các tham số tối ưu.
Tóm lại, chiến lược này vẫn có nhiều không gian để tối ưu hóa, có thể làm cho chiến lược trở nên ổn định và đáng tin cậy hơn thông qua các phương thức như kết hợp các chỉ số, điều chỉnh động lực và nhận thức xu hướng. Ứng dụng học máy cũng là hướng tối ưu hóa có thể được mong đợi trong tương lai.
Tóm tắt
Chiến lược trì hoãn RSI tổng thể Sử dụng chỉ số RSI để đánh giá trường hợp quá mua quá bán và trì hoãn một chu kỳ nhất định sau khi tín hiệu xuất hiện, có thể tránh được sự phá vỡ giả tạo ra tổn thất không cần thiết. Chiến lược này có những lợi thế như xác định chính xác chỉ số, trì hoãn nhập cảnh để tránh phá vỡ giả, có thể điều chỉnh chu kỳ trì hoãn và thực hiện quản lý dừng lỗ. Nhưng cũng có rủi ro của tín hiệu RSI không đáng tin cậy, trì hoãn quá nhiều cơ hội bị mất.
/*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)