Strategi perdagangan grid adaptif dan mekanisme penyesuaian dinamis
MA EMA SMA VWMA TEMA LREG Grid Trading Elasticity Laziness Cooldown
ianzeng123
Ringkasan
Strategi perdagangan grid adaptif adalah strategi kuantitatif yang didasarkan pada sistem perdagangan grid yang menyesuaikan diri dengan perubahan pasar dengan menyesuaikan posisi grid secara otomatis. Strategi ini menggunakan beberapa indikator teknis untuk menghitung titik perdagangan terbaik dan memperbarui grid secara dinamis sesuai dengan perubahan harga.
Prinsip Strategi
Strategi ini didasarkan pada komponen dan prinsip kerja inti berikut:
Mekanisme pengolahan halusStrategi: Pertama-tama melakukan smoothing pada harga, mendukung berbagai jenis moving average (linear regression, SMA, EMA, VWMA, dan TEMA), dan pengguna dapat memilih metode smoothing yang sesuai sesuai dengan preferensi mereka.
Parameter keterlambatanIni adalah inovasi utama dalam strategi ini, dengan memperkenalkan fungsi delay lz ((), sistem akan memperbarui sinyal hanya ketika perubahan harga melebihi persentase tertentu, yang secara efektif menyaring kebisingan pasar.
Mekanisme konstruksi grid:
- Anchor Point sebagai pusat grid, disesuaikan secara dinamis dengan hubungan harga dengan rata-rata bergerak
- Interval Grid (Grid Interval) menentukan jarak antara garis grid yang berdekatan
- Parameter elastisitas ((Elasticity) mengontrol sensitivitas penyesuaian titik fokus
Logika Generasi Sinyal:
- Sinyal beli dihasilkan ketika harga melintasi garis grid dari bawah
- Sinyal jual dihasilkan ketika harga melewati garis grid dari atas
- Opsional menggunakan titik tinggi rendah ((Highs/Lows) atau harga penutupan sebagai kondisi pemicu sinyal
Mekanisme kontrol transaksi:
- Cooldown: Hindari transaksi yang sering
- Filter arah (Direction Filter) dapat memaksakan kebijakan bias ke arah multihead, kosong atau netral
- Batasi area transaksi di dalam garis grid batas atas dan bawah
Pembaruan Jaringan DinamisKetika Lazy Moving Average (LMA) berubah, seluruh struktur grid akan disesuaikan kembali sehingga strategi dapat beradaptasi dengan kisaran harga baru.
Strategi ini menggunakan array untuk menyimpan harga pada setiap garis grid, dan menentukan titik jual dan beli yang spesifik dengan menghitung harga dan persilangan garis grid, dengan mempertimbangkan berbagai kondisi yang membatasi untuk menghindari transaksi yang tidak perlu.
Keunggulan Strategis
AdaptifKeuntungan terbesar dari strategi ini adalah kemampuan untuk secara otomatis menyesuaikan posisi grid sesuai dengan perubahan pasar, tanpa intervensi manusia. Dengan parameter elastisitas dan mekanisme penyesuaian titik pivot, grid dapat bergerak sesuai dengan perubahan tren harga dan selalu tetap relevan.
Filter kebisinganIntroduksi parameter keterlambatan (Laziness) adalah sebuah inovasi yang memastikan bahwa hanya jika perubahan harga cukup signifikan yang memicu penyesuaian grid, yang secara efektif mengurangi respons terhadap kebisingan pasar dan meningkatkan stabilitas strategi.
Fleksibel dan kustomisasiStrategi ini menawarkan banyak pengaturan parameter, termasuk jumlah grid, jarak grid, preferensi arah, jenis smoothing, dan lain-lain, yang dapat disesuaikan oleh pengguna sesuai dengan karakteristik pasar yang berbeda dan gaya perdagangan pribadi.
Daerah perdagangan yang terlihat: Strategi menampilkan area perdagangan aktif saat ini dengan warna yang diisi, sehingga pedagang dapat mengetahui secara intuitif di mana harga saat ini berada di dalam grid, untuk memudahkan pengambilan keputusan.
Pengendalian RisikoDengan membatasi perdagangan hanya dalam jaringan tertentu, strategi ini menciptakan mekanisme kontrol risiko alami untuk mencegah perdagangan yang tidak menguntungkan dalam kondisi pasar yang ekstrem.
Logika masuk dan keluar yang seragam: Menggunakan garis grid yang sama sebagai sinyal beli dan jual, menjaga konsistensi dan prediktabilitas logika perdagangan.
Risiko Strategis
Risiko terobosanStrategi ini pada dasarnya adalah strategi perdagangan interval, yang mungkin menghadapi kerugian berkelanjutan di pasar yang sedang tren kuat. Strategi ini mungkin akan terus mengambil posisi di arah yang salah ketika harga menembus batas bawah grid dan terus bergerak satu arah. Solusinya adalah dengan menambahkan komponen identifikasi tren, atau menghentikan perdagangan grid ketika tren dikonfirmasi.
Parameter SensitivitasKinerja strategi sangat bergantung pada pengaturan parameter, terutama parameter kelam ((Laziness) dan parameter elastisitas ((Elasticity)). Parameter yang tidak tepat dapat menyebabkan penyesuaian grid yang tidak tepat waktu atau terlalu sensitif.
Risiko kepemilikan piramida: Strategi memungkinkan beberapa entri dalam arah yang sama ((pyramiding=4), yang dapat menyebabkan kelebihan leverage dan konsentrasi risiko dalam kondisi pasar yang ekstrim. Pertimbangan harus diberikan untuk mengatur batasan maksimum dan manajemen posisi dinamis.
Titik geser dan dampak biayaStrategi perdagangan grid biasanya melibatkan perdagangan yang sering terjadi, dan dalam pelaksanaan yang sebenarnya, slippage dan biaya dapat secara signifikan mempengaruhi profitabilitas strategi. Faktor-faktor ini perlu dimasukkan dalam pengukuran ulang, dan mungkin perlu menyesuaikan interval grid untuk menyeimbangkan frekuensi perdagangan dengan biaya.
Penanganan Konflik SinyalKetika sinyal jual beli muncul secara bersamaan, strategi saat ini memilih untuk mengabaikan dua sinyal, yang dapat menyebabkan kehilangan peluang perdagangan yang penting. Konflik sinyal dapat dipertimbangkan berdasarkan indikator pasar tambahan atau pola harga.
Arah optimasi strategi
Penyesuaian parameter adaptasiStrategi dapat dioptimalkan lebih lanjut untuk menyesuaikan grid interval dan parameter delay secara otomatis sesuai dengan volatilitas pasar. Sebagai contoh, meningkatkan grid interval di pasar yang berfluktuasi tinggi dan mengurangi grid interval di pasar yang berfluktuasi rendah, sehingga strategi dapat beradaptasi lebih baik dengan kondisi pasar yang berbeda.
Mengintegrasikan komponen identifikasi trenStrategi saat ini mungkin tidak bekerja dengan baik di pasar yang sedang tren, dengan memperkenalkan indikator pengidentifikasi tren (seperti ADX, moving average crossover, dll.), Mengatur arah perdagangan secara otomatis atau menangguhkan perdagangan grid saat mengidentifikasi tren yang kuat.
Manajemen Posisi DinamisStrategi saat ini menggunakan ukuran posisi tetap, yang dapat ditingkatkan menjadi manajemen posisi dinamis berdasarkan perhitungan risiko, seperti penyesuaian ukuran posisi berdasarkan ATR, atau alokasi dana berdasarkan persentase nilai bersih akun.
Analisis multi-frame waktuIntroduksi analisis multi-frame waktu, menggunakan arah tren dari periode waktu yang lebih lama untuk memfilter sinyal perdagangan, hanya melakukan perdagangan grid di arah yang sesuai dengan tren dari frame waktu yang lebih besar.
Mekanisme stop loss yang sempurnaStrategi saat ini tidak memiliki mekanisme stop loss yang jelas. Anda dapat menambahkan stop loss global berdasarkan kondisi pasar secara keseluruhan, atau mengatur titik stop loss terpisah untuk setiap level grid untuk membatasi kerugian maksimum dalam satu transaksi.
Optimalisasi waktu masuk dan keluarStrategi dapat mengintegrasikan volume atau harga dinamika indikator, ketika sinyal grid dipicu, dengan kondisi filter tambahan untuk mengoptimalkan waktu masuk dan keluar tertentu, meningkatkan tingkat keberhasilan.
Integrasi pembelajaran mesin: Menggunakan algoritma pembelajaran mesin dapat dipertimbangkan untuk mengoptimalkan posisi grid dan pilihan parameter, memprediksi pengaturan grid yang optimal melalui model pelatihan data historis, dan meningkatkan kemampuan adaptasi strategi lebih lanjut.
Meringkaskan
Strategi perdagangan grid adaptif mengatasi kekurangan fleksibilitas strategi perdagangan grid tradisional melalui fungsi delay yang inovatif dan mekanisme penyesuaian grid dinamis. Strategi ini dapat secara otomatis beradaptasi dengan perubahan pasar, menangkap peluang perdagangan dalam kisaran harga yang berbeda, sambil mengontrol perilaku perdagangan melalui berbagai parameter.
Meskipun ada masalah potensial seperti risiko terobosan dan sensitivitas parameter, strategi ini memiliki potensi untuk mencapai kinerja yang stabil di berbagai lingkungan pasar dengan mengintegrasikan arah optimasi seperti identifikasi tren dan penyesuaian parameter dinamis. Dalam aplikasi praktis, disarankan untuk memverifikasi kinerja strategi terlebih dahulu melalui pengembalian yang komprehensif, terutama kinerja di berbagai kondisi pasar, dan menyesuaikan parameter sesuai dengan karakteristik varietas perdagangan tertentu, untuk mencapai efek optimal.
//@version=5
// This source code is subject to the terms of the Mozilla Public License 2.0 https://mozilla.org/MPL/2.0/
// ©mvs1231 || xxattaxx
strategy(title='Grid Bot Auto Strategy', shorttitle='GridBot', initial_capital = 100000, overlay=true, pyramiding=4, default_qty_type = strategy.fixed, default_qty_value = 0, commission_value = 0.04, commission_type = strategy.commission.percent, margin_long = 0, margin_short = 0, process_orders_on_close = true)
//----<User Inputs>------------------------------------------------------------------------------//
iLen = input.int(7, 'Smoothing Length(7)', minval=1)
iMA = input.string('lreg', 'Smoothing Type', options=['lreg', 'sma', 'ema', 'vwma', 'tema'])
iLZ = input.float(4.0, 'Laziness(4%)', step=.25) / 100
iELSTX = input(50.0, 'Elasticity(50)')
iGI = input.float(2.0, 'Grid Interval(2%)', step=.25) / 100
iGrids = input.int(6, 'Number of Grids', options=[2, 4, 6, 8])
iCool = input.int(2, 'Cooldown(2)', minval=0)
iDir = input.string('neutral', 'Direction', options=['neutral', 'up', 'down'])
iGT = input.int(70, 'Grid Line Transparency(100 to hide)', minval=0, maxval=100)
iFT = input.int(90, 'Fill Transparency(100 to hide)', minval=0, maxval=100)
iSS = input.string('small', 'Signal Size', options=['small', 'large'])
iReset = input(true, 'Reset Buy/Sell Index When Grids Change')
iEXTR = input(true, 'Use Highs/Lows for Signals')
iMT = input(true, 'Show Min Tick')
iRFC = input(false, 'Reverse Fill Colors')
qty_ent = iGrids/2
qty_pos = strategy.initial_capital / qty_ent / 2 / open
//----<Colors>-----------------------------------------------------------------------------------//
RedGrid = color.new(color.red, iGT)
GreenGrid = color.new(color.green, iGT)
Crimson = #DC143C
LimeGreen = #32CD32
//----<Variables>--------------------------------------------------------------------------------//
NextUP = 0.0
NextDN = 0.0
LastSignal = 0
LastSignal_Index = 0
AP = 0.0
G = iGrids
Buy = false
Sell = false
UpperLimit = 0.0
LowerLimit = 0.0
SignalLine = 0.0
CurrentGrid = 0.0
BuyLine = 0.0
SellLine = 0.0
DIR = 0
MeaningOfLife = 42
//----<Calculations>-----------------------------------------------------------------------------//
//Lazy Formula
lz(x, lzf) =>
LZ = 0.0
s = math.sign(x)
LZ := x == nz(x[1], x) ? x : x > nz(LZ[1] + lzf * LZ[1] * s, x) ? x : x < nz(LZ[1] - lzf * LZ[1] * s, x) ? x : LZ[1]
LZ
//Smoothing
LR = ta.linreg(close, iLen, 0)
SMA = ta.sma(close, iLen)
EMA = ta.ema(close, iLen)
VWMA = ta.vwma(close, iLen)
TEMA = ta.ema(ta.ema(ta.ema(close, iLen), iLen), iLen)
MA = iMA == 'lreg' ? LR : iMA == 'sma' ? SMA : iMA == 'ema' ? EMA : iMA == 'vwma' ? VWMA : TEMA
//Make Lazy
LMA = lz(MA, iLZ)
//Calculate Elasticity
ELSTX = syminfo.mintick * iELSTX
//Show Mintick
if iMT and barstate.islast
table.cell(table.new(position.top_right, 1, 1), 0, 0, str.tostring(syminfo.mintick))
//Anchor Point
AP := MA > LMA ? AP[1] + ELSTX : MA < LMA ? AP[1] - ELSTX : AP[1]
AP := AP >= NextUP[1] ? NextUP[1] : AP
AP := AP <= NextDN[1] ? NextDN[1] : AP
//Reset if Next Level Reached or AP is crossed
AP := LMA != LMA[1] ? LMA : AP
//Next Gridlines
NextUP := LMA != LMA[1] ? LMA + LMA * iGI : NextUP[1]
NextDN := LMA != LMA[1] ? LMA - LMA * iGI : NextDN[1]
//Grid Interval
GI = AP * iGI
//----<Grid Array>-------------------------------------------------------------------------------//
a_grid = array.new_float(9)
for x = -4 to 4 by 1
array.set(a_grid, x + 4, AP + GI * x)
Get_Array_Values(ArrayName, index) =>
value = array.get(ArrayName, index)
value
//----<Set Static Grids>-------------------------------------------------------------------------//
G0 = Get_Array_Values(a_grid, 0) //Upper4
G1 = Get_Array_Values(a_grid, 1) //Upper3
G2 = Get_Array_Values(a_grid, 2) //Upper2
G3 = Get_Array_Values(a_grid, 3) //Upper1
G4 = Get_Array_Values(a_grid, 4) //Center
G5 = Get_Array_Values(a_grid, 5) //Lower1
G6 = Get_Array_Values(a_grid, 6) //Lower2
G7 = Get_Array_Values(a_grid, 7) //Lower3
G8 = Get_Array_Values(a_grid, 8) //Lower4
//----<Set Upper and Lower Limits>---------------------------------------------------------------//
UpperLimit := G >= 8 ? G8 : G >= 6 ? G7 : G >= 4 ? G6 : G5
LowerLimit := G >= 8 ? G0 : G >= 6 ? G1 : G >= 4 ? G2 : G3
//----<Calculate Signals>------------------------------------------------------------------------//
Get_Signal_Index() =>
Value = 0.0
Buy_Index = 0
Sell_Index = 0
start = 4 - G / 2
end = 4 + G / 2
for x = start to end by 1
Value := Get_Array_Values(a_grid, x)
if iEXTR
Sell_Index := low[1] < Value and high >= Value ? x : Sell_Index
Buy_Index := high[1] > Value and low <= Value ? x : Buy_Index
Buy_Index
else
Sell_Index := close[1] < Value and close >= Value ? x : Sell_Index
Buy_Index := close[1] > Value and close <= Value ? x : Buy_Index
Buy_Index
[Buy_Index, Sell_Index]
[BuyLine_Index, SellLine_Index] = Get_Signal_Index()
//----<Signals>----------------------------------------------------------------------------------//
Buy := BuyLine_Index > 0 ? true : Buy
Sell := SellLine_Index > 0 ? true : Sell
//No repeat trades at current level
Buy := low >= SignalLine[1] - GI ? false : Buy
Sell := high <= SignalLine[1] + GI ? false : Sell
//No trades outside of grid limits
Buy := close > UpperLimit ? false : Buy
Buy := close < LowerLimit ? false : Buy
Sell := close < LowerLimit ? false : Sell
Sell := close > UpperLimit ? false : Sell
//Direction Filter (skip one signal if against market direction)
DIR := iDir == 'up' ? 1 : iDir == 'down' ? -1 : 0
Buy := DIR == -1 and low >= SignalLine[1] - GI * 2 ? false : Buy
Sell := DIR == 1 and high <= SignalLine[1] + GI * 2 ? false : Sell
//Conflicting Signals
if Buy and Sell
Buy := false
Sell := false
LastSignal_Index := LastSignal_Index[1]
LastSignal_Index
//----<Cooldown>---------------------------------------------------------------------------------//
y = 0
for i = 1 to iCool by 1
if Buy[i] or Sell[i]
y := 0
break
y += 1
y
CoolDown = y
Buy := CoolDown < iCool ? false : Buy
Sell := CoolDown < iCool ? false : Sell
//----<Trackers>---------------------------------------------------------------------------------//
LastSignal := Buy ? 1 : Sell ? -1 : LastSignal[1]
LastSignal_Index := Buy ? BuyLine_Index : Sell ? SellLine_Index : LastSignal_Index[1]
SignalLine := Get_Array_Values(a_grid, LastSignal_Index)
//Reset to Center Grid when LMA changes
if iReset
SignalLine := LMA < LMA[1] ? UpperLimit : SignalLine
SignalLine := LMA > LMA[1] ? LowerLimit : SignalLine
SignalLine
BuyLine := Get_Array_Values(a_grid, BuyLine_Index)
SellLine := Get_Array_Values(a_grid, SellLine_Index)
//----<Plot Grids>--------------------------//
color apColor = na
apColor := MA < AP ? color.new(color.red, iGT) : MA > AP ? color.new(color.green, iGT) : apColor[1]
apColor := LMA != LMA[1] ? na : apColor
plot(G >= 8 ? G0 : na, color=GreenGrid)
plot(G >= 6 ? G1 : na, color=GreenGrid)
plot(G >= 4 ? G2 : na, color=GreenGrid)
plot(G >= 2 ? G3 : na, color=GreenGrid)
plot(G4, color=apColor, linewidth=4) // Center
plot(G >= 2 ? G5 : na, color=RedGrid)
plot(G >= 4 ? G6 : na, color=RedGrid)
plot(G >= 6 ? G7 : na, color=RedGrid)
plot(G >= 8 ? G8 : na, color=RedGrid)
//fill
LineAbove = SignalLine == UpperLimit ? SignalLine : SignalLine + GI
LineBelow = SignalLine == LowerLimit ? SignalLine : SignalLine - GI
a = plot(LineAbove, color=color.new(color.red, 100), style=plot.style_circles)
b = plot(LineBelow, color=color.new(color.green, 100), style=plot.style_circles)
boxColor = LastSignal == 1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
if iRFC
boxColor := LastSignal == -1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
boxColor
fill(a, b, color=boxColor)
//----<Plot Signals>-----------------------------------------------------------------------------//
plotchar(Buy and iSS == 'small', 'Buy', color=color.new(LimeGreen, 0), size=size.tiny, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'small', 'Sell', color=color.new(Crimson, 0), size=size.tiny, location=location.abovebar, char='▼')
plotchar(Buy and iSS == 'large', 'Buy', color=color.new(LimeGreen, 0), size=size.small, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'large', 'Sell', color=color.new(Crimson, 0), size=size.small, location=location.abovebar, char='▼')
//----<Alerts>-----------------------------------------------------------------------------------//
alertcondition(condition=Buy, title='buy', message='buy')
alertcondition(condition=Sell, title='sell', message='sell')
//-----------------------------------------------------------------------------------------------//
if strategy.position_size >= 0 and Buy
strategy.entry("Long", strategy.long, qty = qty_pos)
if strategy.position_size <= 0 and Sell
strategy.entry("Short", strategy.short, qty = qty_pos)
if strategy.position_size > 0 and Sell
strategy.close("Long", qty = qty_pos)
if strategy.position_size < 0 and Buy
strategy.close("Short", qty = qty_pos)