Mengkoordinasikan Sliding Stop Loss Strategy

Penulis:ChaoZhang, Tarikh: 2023-11-02 16:28:55
Tag:

Ringkasan

Strategi ini menggunakan Stochastic RSI dan penunjuk kadar perubahan harga untuk mengenal pasti arah trend untuk masuk, dan menyelaraskan stop loss bergerak untuk pengurusan risiko.

Logika Strategi

Pertama, strategi ini mengira RSI Stochastic menggunakan penunjuk RSI dengan panjang 5 dan penunjuk Stochastic dengan panjang 7. Apabila nilai RSI Stochastic K di atas nilai D, ia adalah isyarat kenaikan. Apabila K di bawah D, ia adalah isyarat penurunan.

Kedua, strategi ini mengira kadar perubahan harga penunjuk EMA ROC. Apabila EMA ROC melebihi separuh ambang atau di bawah separuh negatif ambang, ia mengenal pasti pergerakan harga aktif.

Kemudian, menggabungkan isyarat Stochastic RSI dan kadar perubahan harga, ia mengenal pasti arah trend. Apabila Stochastic RSI bullish dan harga bergerak secara aktif, pergi panjang. Apabila Stochastic RSI bearish dan harga bergerak secara aktif, pergi pendek.

Akhirnya, strategi ini menggunakan stop loss bergerak koordinat untuk pengurusan risiko. Selepas membuka kedudukan, ia terus menyegarkan harga tertinggi / terendah, dan menggunakan jarak peratusan tertentu dari harga tertinggi / terendah sebagai tahap stop loss.

Analisis Kelebihan

Kelebihan strategi ini:

Indikator RSI Stochastic secara berkesan mengenal pasti trend dan situasi overbought / oversold.
Kadar perubahan harga menapis pasaran terhad julat untuk mengelakkan isyarat palsu.
Stop loss bergeser yang diselaraskan boleh mengunci keuntungan sejauh mungkin sambil mengawal risiko.
Strategi ini mempunyai ruang pengoptimuman yang besar untuk parameter yang diselaraskan berdasarkan produk yang berbeza.
Logik strategi adalah mudah dan jelas, mudah difahami dan dilaksanakan.

Analisis Risiko

Risiko strategi ini:

Stochastic RSI boleh menghasilkan isyarat palsu, memerlukan pengesahan dengan faktor lain.
Stop loss bergeser koordinat mungkin terlalu agresif, boleh dihentikan oleh jurang semalaman.
Pembalikan jangka pendek boleh mencetuskan stop loss.
Parameter perlu dioptimumkan untuk produk yang berbeza, jika tidak prestasi mungkin buruk.
Kos dagangan memberi kesan kepada keuntungan strategi, kekerapan dagangan yang munasabah diperlukan.

Arahan pengoptimuman

Strategi ini boleh dioptimumkan lagi dalam aspek berikut:

Mengoptimumkan parameter RSI Stochastic untuk mengurangkan isyarat palsu. Boleh menguji nilai K dan D yang berbeza.
Mengoptimumkan kadar harga parameter perubahan untuk meningkatkan kesan penapisan.
Tambah penunjuk trend untuk mengelakkan terhalang oleh pembalikan.
Mengoptimumkan peratusan stop loss untuk mengurangkan risiko terperangkap. Boleh menguji lebar stop loss yang berbeza.
Tambah pengurusan saiz kedudukan untuk mengawal risiko perdagangan tunggal. seperti jumlah stop loss tetap, atau menyesuaikan saiz kedudukan secara dinamik berdasarkan ekuiti akaun.
Uji parameter pada produk yang berbeza untuk meningkatkan daya adaptasi.

Ringkasan

Ringkasnya, strategi ini mempunyai logik yang jelas dan mudah, mengenal pasti arah trend dengan RSI Stochastic dan menapis isyarat dengan kadar perubahan harga, yang dapat menangkap trend jangka menengah dan panjang dengan berkesan.

/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Sto2", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)

/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true
    
///////////// Stochastic calc /////////////
smoothK = input(1, minval=1)
smoothD = input(7, minval=1)
lengthRSI = input(5, minval=1)
lengthStoch = input(7, minval=1)
src = input(close, title="RSI Source")

up = sma(max(change(src), 0), lengthRSI) 
down = sma(-min(change(src), 0), lengthRSI)
rsi1 = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))

k = sma(stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = sma(k, smoothD)

///////////// Rate Of Change ///////////// 
source = close, roclength = input(14, minval=1), pcntChange = input(2, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))

/////////////// STRATEGY ///////////////
long = k > d and isMoving()
short = k < d and isMoving()

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(9.0, title='Take Profit %') / 100 
 
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp) 

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) // LONG SL
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) // SHORT SL

slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na

// Strategy
if testPeriod()
    strategy.entry("Long Entry",  strategy.long, when=long)
    strategy.entry("Short Entry", strategy.short, when=short)
    strategy.exit("Long Ex", "Long Entry", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("Short Ex", "Short Entry", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
    
///////////// Plotting /////////////
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
p1 = plot(k, color=color.gray, linewidth=0)
p2 = plot(d, color=color.gray, linewidth=0)
h0 = hline(100)
h1 = hline(50)
h3 = hline(0)
fill(p1, p2, color = k > d ? color.lime : color.red, transp=70)

Lebih lanjut

2019 FMZ - Semua hak dilindungi