Strategi Rata-rata Gerak Spiral Breakout

Penulis:ChaoZhang, Tanggal: 2024-01-15 11:45:23
Tag:

Gambaran umum

Strategi ini menggabungkan indikator Spiral Channel dan indikator Rate of Change (ROC). Strategi ini menghasilkan sinyal beli ketika harga menembus band atas dan moving average, dan sinyal jual ketika harga menembus band bawah dan moving average.

Logika Strategi

Strategi ini didasarkan pada dua indikator utama:

Saluran Spiral: Membuat grafik band atas dan bawah untuk menentukan arah tren. Harga yang pecah di atas band atas menunjukkan tren naik, sementara pecah di bawah band bawah menandakan tren menurun.
Rate of Change (ROC): mendeteksi percepatan harga. ROC di atas ambang positif menunjukkan percepatan pergerakan harga ke atas, sementara ROC di bawah ambang negatif menunjukkan percepatan pergerakan ke bawah.

Sinyal beli dihasilkan ketika baik Spiral Channel dan ROC memberikan indikasi bullish, yaitu harga melanggar band atas ditambah dengan percepatan momentum naik. Sinyal jual dipicu ketika kedua indikator berubah menjadi bearish.

Sinyal gabungan membantu menghindari perdagangan melawan tren dan meningkatkan keandalan.

Keuntungan

Sinyal yang dapat diandalkan dengan tingkat kemenangan yang lebih tinggi dengan membutuhkan kesepakatan antara tren dan momentum.
Frekuensi perdagangan yang dapat disesuaikan melalui pengaturan parameter, misalnya menyesuaikan parameter ROC.
Stop loss untuk membatasi risiko penurunan pada perdagangan individu.
Masuk kembali mekanisme untuk naik tren dan lebih meningkatkan profitabilitas.

Risiko

Kehilangan beberapa peluang perdagangan dan membatasi potensi keuntungan karena persyaratan keandalan sinyal.
Cacat untuk terjebak ketika tren berbalik, berpotensi menyebabkan kerugian besar.
Penyesuaian parameter yang buruk dapat mengakibatkan terlalu sedikit atau terlalu banyak sinyal.
Persentase stop loss tetap tidak mampu mencegah kerugian parah pada perubahan harga yang sangat merugikan.

Peluang Peningkatan

Optimalkan parameter ROC untuk kinerja terbaik.
Uji tingkat stop loss yang berbeda untuk menyeimbangkan risiko dan imbalan.
Tambahkan filter lain seperti volume, indikator volatilitas untuk memperbaiki sinyal.
Evaluasi kinerja di berbagai pasar untuk menemukan yang paling cocok.
Memperkenalkan ukuran posisi dinamis untuk kondisi pasar yang bervariasi.

Kesimpulan

Strategi ini menggabungkan Spiral Channel dan ROC untuk menilai arah tren dan momentum. Ini bertujuan untuk keandalan sinyal sambil mempertahankan profitabilitas melalui re-entry dan tuning parameter. Risiko terutama dikendalikan oleh stop loss persentase tetap. Secara keseluruhan, ini adalah kerangka kerja yang relatif lengkap yang layak sebagai strategi perdagangan kuantitatif dasar.

/*backtest
start: 2024-01-07 00:00:00
end: 2024-01-14 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("SSL Chaikin BF 🚀", overlay=true, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)

/////////////// Time Frame ///////////////
_0 = input(false,  "════════ Test Period ═══════")
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

/////////////// Chaikin MF /////////////// 
_1 = input(false,  "═══════ Chaikin MF ═══════")
length = input(20, minval=1, title = "Chaikin SMA Length")
upperThreshold = input(0.04, step=0.01, title="Upper Threshold")
lowerThreshold = input(0.02, step=0.01, title="Lower Threshold")
ad = close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume
mf = sum(ad, length) / sum(volume, length)

/////////////// SSL Channels /////////////// 
_2 = input(false,  "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)

smaHigh = sma(high, len1)
smaLow = sma(low, len2)

Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh

///////////// Rate Of Change ///////////// 
_3 = input(false,  "══════ Rate of Change ══════")
source = close
roclength = input(13, "ROC Length",  minval=1)
pcntChange = input(4, "ROC % Change", 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 = sslUp > sslDown and isMoving() or crossover(mf, upperThreshold)
short = sslUp < sslDown and isMoving() or crossunder(mf, lowerThreshold)

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])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

//////////////// Stop loss /////////////// 
_4 = input(false,  "════════ Stop Loss ═══════")
sl_inp = input(2.0, title='Stop Loss %') / 100

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

/////////////// Execution /////////////// 
if testPeriod()
    strategy.entry("L", strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, when=since_shortEntry > 0)

/////////////// Plotting /////////////// 
p1 = plot(sslDown, linewidth = 1, color=color.red)
p2 = plot(sslUp, linewidth = 1, color=color.lime)
fill(p1, p2,  color = sslDown < sslUp ? color.lime : color.red, transp=80)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(crossover(mf, upperThreshold) ? color.blue : crossunder(mf, lowerThreshold) ? color.orange : na, transp=30)

Lebih banyak

2019 FMZ - Semua hak dilindungi