Strategi Aliran Berasaskan Nisbah Kelantangan
ChaoZhang
Artikel ini akan menerangkan secara terperinci satu strategi kuantitatif berdasarkan nisbah urus niaga untuk menentukan arah trend. Strategi ini menghasilkan isyarat beli dan jual dengan mengira garis purata urus niaga kosong.
I. Prinsip-prinsip Strategi
Penunjuk utama strategi ini adalah jumlah transaksi kosong. Langkah-langkah pengiraan adalah seperti berikut:
Mengira jumlah dagangan pada hari tersebut.
Apabila K dianggap berbilang, jumlah dagangan akan ditulis sebagai jumlah dagangan berbilang pihak (Bull Volume).
Apabila garis K dianggap kosong, jumlah transaksi ditulis sebagai jumlah transaksi kosong (Bear Volume).
Mengira purata bergerak pertukaran antara dua segi.
Apabila banyak pihak bergerak pada rata-rata bergerak yang melintasi, menghasilkan isyarat beli; sebaliknya menghasilkan isyarat jual.
Ia juga menyaring melalui indikator kadar perubahan harga dan hanya berdagang apabila terdapat trend harga yang jelas.
Tetapkan titik henti rugi untuk mengunci keuntungan mengikut isyarat.
Dengan cara ini, arah trend dapat ditentukan melalui perkadaran kosong jumlah transaksi, dan penapisan dengan penunjuk kadar perubahan harga dapat meningkatkan kualiti isyarat. Tetapan Stop Loss Stop juga membolehkan setiap perdagangan mempunyai kerugian yang terkawal.
Kedua, kelebihan strategi
Kelebihan utama strategi ini adalah menggunakan jumlah transaksi untuk menentukan arah trend, yang merupakan salah satu kaedah asas untuk menentukan trend. Jumlah transaksi dapat mencerminkan tingkah laku peserta pasaran.
Selain itu, indikator kuantiti transaksi juga dapat mencerminkan isyarat penembusan lebih awal dan lebih sensitif. Ia dapat menangkap perubahan trend lebih awal daripada hanya menggunakan indikator harga.
Akhir sekali, penapisan yang digabungkan dengan indikator kadar perubahan harga juga meningkatkan kualiti isyarat.
Ketiga, potensi risiko
Walaupun ada kelebihan, strategi ini juga mempunyai risiko yang perlu diperhatikan di dalam talian:
Pertama, anda perlu berhati-hati dalam menetapkan parameter penunjuk lalu lintas untuk mengelakkan isyarat palsu.
Kedua, bergantung kepada satu indikator sahaja yang mudah dirobohkan oleh harga yang tidak sah. Ia harus disahkan oleh pelbagai kombinasi indikator.
Akhirnya, penyetempatan stop loss terlalu dekat boleh menyebabkan risiko penyetempatan stop loss akan ditembusi.
Empat isi, ringkasan
Artikel ini menerangkan secara terperinci satu strategi kuantitatif yang menggunakan trend penilaian kadar urus niaga. Ia boleh menghasilkan isyarat perdagangan dengan mengira garis purata urus niaga kosong. Strategi ini mempunyai keunggulan tertentu, tetapi juga perlu disahkan dengan indikator lain.
/*backtest
start: 2023-08-14 00:00:00
end: 2023-09-13 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Based on Volume Flow v3 indicator by oh92
strategy("Volume Flow BF", 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
maType = input(title="Moving Average Type", options=["Simple", "Exponential", "Double Exponential"], defval="Simple")
length = input(6, title="MA Length")
x = input(3.1, title="Factor For Breakout Candle")
// Basic Volume Calcs //
vol = volume
bull = close>open?vol:0
bear = open>close?vol:0
// Double EMA Function //
dema(src, len) => (2 * ema(src, len) - ema(ema(src, len), len))
// BULL Moving Average Calculation
bullma = maType == "Exponential" ? ema(bull, length) :
maType == "Double Exponential" ? dema(bull, length) :
sma(bull, length)
// BEAR Moving Average Calculation //
bearma = maType == "Exponential" ? ema(bear, length) :
maType == "Double Exponential" ? dema(bear, length) :
sma(bear, length)
///////////// Rate Of Change /////////////
source = close
roclength = input(12, 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 = bullma > bearma and isMoving()
short = bullma < bearma 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(900.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])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
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("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", 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)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
plot(bullma, color=color.lime, linewidth=1, transp=0, title="Bull MA", transp=10)
plot(bearma, color=color.red, linewidth=1, transp=0, title="Bear MA", transp=10)