Strategi Perdagangan Osilator Rata-rata Pergerakan Hull


Tanggal Pembuatan: 2023-10-07 15:24:31 Akhirnya memodifikasi: 2023-10-07 15:24:31
menyalin: 0 Jumlah klik: 1028
1
fokus pada
1617
Pengikut

Ringkasan

Strategi ini adalah strategi perdagangan garis pendek berdasarkan indikator Hull Moving Average. Strategi ini menggunakan Hull Moving Average untuk membentuk sinyal jual beli dan merupakan strategi pelacakan tren.

Prinsip Strategi

Strategi ini didasarkan pada indikator Hull Moving Average, yang terdiri dari dua rata-rata bergerak. Pertama, menghitung harga rata-rata bergerak menengah (nma) dengan periode hullperiod. Kemudian menghitung harga rata-rata bergerak cepat (n2ma) dengan periode setengah nma.

Untuk memfilter beberapa sinyal palsu, strategi ini juga memperkenalkan garis Hull ((Hull_Line)). Garis Hull adalah hasil dari regresi linier yang dihitung dari perbedaan antara nma dan n2ma. Strategi ini akan melewati sinyal beli dan jual ketika harga menyimpang dari garis Hull.

Secara khusus, aturan strategi adalah sebagai berikut:

  1. Perhitungan nma, periode hullperiod

  2. Perhitungan n2ma, siklus adalah setengah dari siklus nma

  3. Hitung perbedaan n2ma dan nma

  4. Hull_Line adalah rata-rata bergerak dari periode sqrt{\displaystyle \sqrt{\hull_period }

  5. Sinyal beli saat harga melewati garis Hull

  6. Sinyal jual saat harga di bawah garis Hull

  7. Jika harga menyimpang dari garis Hull, skip sinyal

  8. Posisi masuk dengan proporsi tertentu, menggunakan metode stop loss

Analisis Keunggulan

Strategi ini memiliki keuntungan sebagai berikut:

  1. Berdasarkan Hull Moving Average, kita bisa menangkap tren dengan cepat, dan trendnya akan berubah seiring waktu.

  2. Filter sinyal palsu dengan menggunakan kabel Hull untuk meningkatkan kualitas sinyal

  3. Rasio penarikan dan penghematan yang baik, cocok untuk operasi garis pendek

  4. Fleksibilitas penyesuaian parameter untuk menyesuaikan dengan kondisi pasar yang berbeda

  5. Menggunakan Reverse Stop Loss, dapat menghentikan kerugian tepat waktu, mengendalikan risiko

  6. Risiko sistematis yang dapat dihindari dalam jangka waktu tertentu, dikombinasikan dengan musiman

Analisis risiko

Strategi ini juga memiliki beberapa risiko:

  1. Strategi mengikuti tren, tidak bisa melakukan perdagangan sepanjang waktu

  2. Ketika tren berbalik, akan ada kerugian yang lebih besar

  3. Sistem rata-rata bergerak terlambat dan tidak dapat menangkap titik balik tepat waktu

  4. Transaksi singkat sering terjadi dan biaya transaksi tinggi

  5. Pengaturan parameter yang tidak tepat dapat menyebabkan penurunan pendapatan di pasar yang bergoyang

Untuk mengatasi risiko tersebut, langkah-langkah berikut dapat diambil:

  1. Menggunakan strategi stop loss Martingale untuk mengendalikan kerugian tunggal

  2. Optimalisasi parameter, pengujian kekuatan parameter dalam berbagai lingkungan pasar

  3. Indikator penilaian tren, untuk menghindari penurunan yang tidak terhindarkan dalam pembalikan

  4. Meningkatkan waktu penyimpanan dan mengurangi frekuensi transaksi

Arah optimasi

Strategi ini juga dapat dioptimalkan dalam beberapa hal:

  1. Kombinasi dengan indikator momentum, menentukan titik awal tren, dan penempatan yang lebih baik

  2. Menambahkan model pembelajaran mesin untuk membantu menentukan arah dan intensitas tren

  3. Menggunakan pengaturan parameter adaptif, menyesuaikan parameter sesuai dengan pasar real-time

  4. Konfigurasi sistem Hull multi-periode, konfigurasi posisi yang berbeda untuk periode yang berbeda

  5. Dengan indikator energi volume transaksi, menghindari terjadinya terobosan palsu yang tidak mencukupi

  6. Menambahkan modul manajemen posisi berdasarkan volatilitas, menyesuaikan posisi secara dinamis berdasarkan volatilitas

Meringkaskan

Strategi perdagangan rata-rata bergerak Hull secara keseluruhan adalah strategi pelacakan garis pendek yang sangat praktis. Ini menggunakan sistem rata-rata bergerak Hull untuk menilai arah tren untuk mencapai posisi yang baik. Ini memiliki kualitas sinyal dan fleksibilitas parameter yang lebih tinggi dibandingkan dengan sistem rata-rata bergerak tunggal.

Kode Sumber Strategi
/*backtest
start: 2023-09-06 00:00:00
end: 2023-10-06 00:00:00
period: 6h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
//                               Hull Moving Average Swing Trader by SEASIDE420
strategy("Hull Moving Average Swing Trader", shorttitle="HMA_Swing_Trader", default_qty_type=strategy.percent_of_equity, default_qty_value=100, calc_on_order_fills=true, calc_on_every_tick=true, pyramiding=0)
hullperiod = input(title="HullMA Period", type=input.integer, defval=210, minval=1)
price = input(open, type=input.source, title="Price data")
FromMonth = input(defval=1, title="From Month", minval=1, maxval=12)
FromDay = input(defval=1, title="From Day", minval=1, maxval=31)
FromYear = input(defval=2020, title="From Year", minval=2017)
ToMonth = input(defval=1, title="To Month", minval=1, maxval=12)
ToDay = input(defval=1, title="To Day", minval=1, maxval=31)
ToYear = input(defval=9999, title="To Year", minval=2017)
start = timestamp(FromYear, FromMonth, FromDay, 00, 00)
finish = timestamp(ToYear, ToMonth, ToDay, 23, 59)
window() => true
n2ma = 2 * wma(price, round(hullperiod / 2))
nma = wma(price, hullperiod)
diff = n2ma - nma
sqn = round(sqrt(hullperiod))
n2ma1 = 2 * wma(price[1], round(hullperiod / 2))
nma1 = wma(price[1], hullperiod)
diff1 = n2ma1 - nma1
n1 = wma(diff, sqn)
n2 = wma(diff1, sqn)
Hull_Line = n1 / n1 * n2
Hull_retracted = if n1 > n2
    Hull_retracted = Hull_Line - 2
else
    Hull_retracted = Hull_Line + 2
c1 = Hull_retracted + n1 - price
c2 = Hull_retracted - n2 + price
c4 = n1 > n2 ? color.green : color.red
c2p = plot(c2, color=color.black, linewidth=1)
c3p = plot(price, color=color.black, linewidth=1)
fill(c3p, c2p, color=c4, transp=75)
//plot(cross(c1, c2) ? c1 : na, style=plot.style_circles, color=c4, linewidth=4)
if price < c2
    strategy.close("BUY", when=window())
if price > c2
    strategy.close("SELL", when=window())
if price > c2 and price[1] > c1
    strategy.entry("BUY", strategy.long, when=window())
if price < c1 and price[1] < c2
    strategy.entry("SELL", strategy.short, when=window())  //        /L'-, 
//                               ,'-.      `   ````                 /  L '-, 
//     .                    _,--dMMMM\        `   ` ` '`..         /       '-, 
//     :             _,--,  )MMMMMMMMM),.      `     ,<>          /_      '-,' 
//     ;     ___,--. \MM(    `-'   )M//MM\          ,',.;      .-'* ;     .' 
//     |     \MMMMMM) \MM\       ,dM//MMM/     ___ < ,; `.      )`--'    / 
//     |      \MM()M   MMM)__   /MM(/MP'  ___, \  \ `  `. `.   /__,    ,' 
//     |       MMMM/   MMMMMM( /MMMMP'__, \     | /      `. `-,_\     / 
//     |       MM     /MMM---' `--'_ \     |-'  |/         `./ .\----.___ 
//     |      /MM'   `--' __,-  \""   |-'  |_,               `.__) . .F. )-. 
//     |     `--'       \   \    |-'  |_,     _,-/            J . . . J-'-. `-., 
//     |         __  \`. |   |   |         \    / _           |. . . . \   `-.  F 
//     |   ___  /  \  | `|   '      __  \   |  /-'            F . . . . \     '` 
//     |   \  \ \  /  |        __  /  \  |  |,-'        __,- J . . . . . \ 
//     |    | /  |/     __,-  \  ) \  /  |_,-     __,--'     |. .__.----,' 
//     |    |/    ___     \    |'.  |/      __,--'           `.-;;;;;;;;;\ 
//     |     ___  \  \     |   |  `   __,--'                  /;;;;;;;;;;;;. 
//     |     \  \  |-'\    '    __,--'                       /;;;;;;;;;;;;;;\ 
// \   |      | /  |      __,--'                             `--;;/     \;-'\ 
//  \  |      |/    __,--'                                   /  /         \  \ 
//   \ |      __,--'                                        /  /           \  \ 
//    \|__,--'                                          _,-;M-K,           ,;-;\ 
//                                                     <;;;;;;;;           '-;;;; 
//                                                                                  :D