Sistem Perdagangan Adaptif Momentum Tren Entropi Multidimensi
CETP-Plus Shannon Entropy RSI ATR ADX EMA momentum 3D Histogram Volatility Filter
ianzeng123
Ringkasan
Sistem perdagangan multidimensional yang beradaptasi dengan tren yang bergerak adalah strategi perdagangan kuantitatif yang didasarkan pada teori pivot, dengan inti indikator CETP-Plus, yang “berurutan” dalam pola pivot yang diukur oleh Shannon. Sistem ini menggabungkan prinsip-prinsip penimbangan terbaru dari indeks moving average (EMA), deviasi dinamis relatif kuat dari RSI (RSI), skala volatilitas rata-rata real real (ATR), dan kekuatan tren dari indeks arah rata-rata (ADX) ke dalam satu penilaian.
Prinsip Strategi
Prinsip inti dari strategi ini adalah untuk mengaplikasikan algoritma Shannon dalam analisis pola grafik pasar keuangan. The algoritma Shannon berasal dari teori informasi, digunakan untuk mengukur ketidakpastian atau “kebingungan” dari variabel acak. Dalam strategi ini, algoritma ini dihitung dan diterapkan dengan cara berikut:
- Perhitungan rasio kalsiumStrategi pertama menghitung tiga rasio ketukan utama - rasio entitas (yang mencerminkan kekuatan tren), rasio garis bayangan atas dan rasio garis bayangan bawah (yang mencerminkan potensi pembalikan).
- Indeks penurunan berat badan: Menggunakan faktor penurunan ((0.8) untuk memberi bobot pada data peta sejarah, memberikan bobot yang lebih tinggi pada data terbaru, mirip dengan cara kerja EMA.
- Peta tiga dimensi: menempatkan rasio ke dalam grafik tiga dimensi, dengan dimensi yang sesuai dengan entitas, garis atas dan bawah bayangan.
- Perhitungan kalsium: Menggunakan rumus Shannon untuk menghitung threshold dari sebuah grafik persegi panjang, threshold rendah menunjukkan adanya pola yang kuat.
- Integrasi deviasi momentum: Metode perhitungan yang mirip dengan RSI untuk menangkap pergerakan harga dan menyesuaikan skor rasio.
- Perubahan intensitas trenMetode perhitungan yang mirip dengan ADX mendeteksi arah dan intensitas tren, untuk menyesuaikan skor lebih lanjut.
- Adaptasi volatilitas: Menggunakan ATR untuk skala volatilitas untuk memastikan sinyal konsisten dalam lingkungan yang berbeda.
Skor CETP akhir adalah produk gabungan dari faktor-faktor ini, nilai positif cenderung ke arah bullish, nilai negatif cenderung ke arah bearish. Logika perdagangan sederhana dan langsung: lakukan lebih banyak ketika skor CETP melebihi nilai positif yang ditetapkan, dan kosong jika lebih rendah dari nilai negatif. Untuk menghindari perdagangan mikro, strategi ini menambahkan filter pergerakan harga minimum untuk memastikan bahwa grafik saat ini memiliki jangkauan yang cukup untuk memicu perdagangan.
Keunggulan Strategis
Sinyal IntegrasiIndikator CETP-Plus menggabungkan keunggulan dari berbagai indikator tradisional (EMA, RSI, ATR, ADX) untuk memberikan sinyal perdagangan yang jelas dan tunggal, menghindari risiko konflik indikator dan over-fitting.
AdaptifStrategi dapat menyesuaikan diri secara otomatis dengan kondisi pasar, beradaptasi dengan lingkungan yang berbeda dan intensitas tren yang berfluktuasi, dan dapat bekerja dengan baik dalam berbagai kondisi pasar tanpa intervensi manual.
Pengolahan polygonal simetrisStrategi memberi bobot yang sama pada peluang overhead dan overhead, sehingga mereka dapat beroperasi secara efektif di pasar bullish dan bearish, tanpa dipengaruhi oleh bias arah.
Identifikasi tren awalDengan konsep capture the change, kita dapat mengidentifikasi awal pembentukan tren sebelum indikator tradisional, memberikan waktu yang lebih baik untuk masuk.
Mengurangi dampak kebisinganDengan menggunakan analisa pivot dan teknik pembagian kotak grafik vertikal, strategi dapat membedakan sinyal nyata dan kebisingan pasar, mengurangi terjadinya sinyal palsu.
KustomisasiBanyaknya parameter dapat dioptimalkan sesuai dengan varietas perdagangan dan kerangka waktu yang berbeda, sehingga strategi memiliki fleksibilitas dan kemampuan beradaptasi yang tinggi.
Manajemen risiko yang lengkapTerintegrasi dengan mekanisme kontrol risiko multi-tingkat, termasuk stop loss persentase, stop loss dinamis berbasis ATR dan stop loss pelacakan, dan filter perdagangan minimum, yang mengontrol penarikan secara efektif.
Risiko Strategis
Parameter SensitivitasStrategi ini mencakup beberapa parameter yang dapat disesuaikan, dan optimasi yang berlebihan dapat menyebabkan kinerja yang buruk dalam perdagangan langsung. Lingkungan pasar yang berbeda mungkin memerlukan pengaturan parameter yang berbeda, sehingga pemeliharaan sistem menjadi rumit.
Risiko perdagangan frekuensi tinggiStrategi ini dapat menghasilkan banyak sinyal perdagangan, terutama di pasar yang sangat fluktuatif, yang menyebabkan overtrading, peningkatan biaya komisi, dan peningkatan slippage.
Kompleksitas perhitungan: Perhitungan kotak-kotak dan kotak-kotak dalam grafik 3D dapat membutuhkan sumber daya komputasi yang lebih tinggi saat dilakukan secara real time, yang dapat menyebabkan keterlambatan dalam pelaksanaan, terutama pada jangka waktu yang lebih pendek.
Hipotesis algoritma risikoStrategi ini didasarkan pada asumsi bahwa ketumbar dapat secara efektif menangkap pola pasar, tetapi struktur pasar dapat berubah seiring waktu, sehingga asumsi ini tidak valid.
Kecenderungan fluktuatifStrategi: menggunakan filter volatilitas dan filter pergerakan harga minimum, kemungkinan kehilangan peluang perdagangan dalam lingkungan volatilitas rendah, kemungkinan terlalu sensitif dalam lingkungan volatilitas tinggi.
Risiko dari sejarahMeskipun strategi ini menggabungkan keunggulan dari berbagai indikator, masih ada risiko over-fitting dari data historis, dan perubahan kondisi pasar di masa depan dapat menyebabkan penurunan kinerja.
Solusi meliputi: optimasi ulang parameter secara teratur, pengujian parameter yang valid dengan pengujian stepwise, penerapan kondisi penyaringan yang lebih ketat untuk mengurangi frekuensi transaksi, peningkatan kondisi konfirmasi untuk meningkatkan kualitas sinyal, dan kinerja sistem pemantauan real-time untuk menyesuaikan parameter risiko.
Arah optimasi strategi
Mekanisme parameter adaptasiOptimalisasi ini memungkinkan sistem untuk lebih beradaptasi dengan kondisi pasar yang berubah, mengurangi kebutuhan untuk intervensi manual.
Integrasi analisis multi-frame waktu: Mengintegrasikan sinyal CETP dari kerangka waktu yang berbeda untuk menciptakan sistem konfirmasi hierarki. Sebagai contoh, hanya melakukan perdagangan ketika sinyal kerangka waktu yang lebih tinggi sesuai dengan sinyal kerangka waktu perdagangan, meningkatkan tingkat kemenangan.
Pembelajaran Mesin: Menggunakan algoritma pembelajaran mesin untuk mengoptimalkan pilihan parameter dan pemfilteran sinyal. Menggunakan pembelajaran pengawasan untuk mengidentifikasi kombinasi parameter yang berkinerja terbaik, atau menggunakan algoritma pengelompokan untuk mengidentifikasi keadaan pasar yang berbeda dan menyesuaikan strategi sesuai.
Filter likuiditas dan volume transaksi: Menambahkan filter berdasarkan volume transaksi dan kedalaman pasar untuk memastikan bahwa transaksi dilakukan hanya dalam kondisi likuiditas yang memadai, mengurangi slippage dan risiko eksekusi.
Analisis korelasi multi-aset: Mengintegrasikan informasi dari pasar terkait (misalnya indeks, saham atau komoditas terkait) untuk meningkatkan keyakinan perdagangan ketika sinyal yang sama muncul di beberapa pasar terkait
Model Prediksi Volatilitas: Mengembangkan komponen prediksi volatilitas, menyesuaikan threshold dan parameter risiko lebih awal, untuk mempersiapkan lingkungan volatilitas yang akan datang.
Kerangka pengamatan dan optimasi otomatisDengan membangun sistem otomatisasi, evaluasi strategi secara berkala dengan data baru dan penyesuaian parameter sesuai dengan perilaku pasar terbaru, memastikan strategi tetap adaptif.
Optimalisasi di atas bertujuan untuk meningkatkan stabilitas, adaptasi, dan profitabilitas strategi, sekaligus mengurangi kebutuhan akan intervensi manusia dan risiko over-adaptasi. Dengan menerapkan optimalisasi secara bertahap, sistem perdagangan yang lebih cerdas dan otonom dapat dibangun.
Meringkaskan
Sistem perdagangan beradaptasi dengan tren kuantitatif multi-dimensi mewakili metode perdagangan kuantitatif yang inovatif, yang menangkap keteraturan dan prediktabilitas dalam pola harga dengan menerapkan konsep keteraturan dalam teori informasi ke pasar keuangan. Keunggulan inti dari strategi ini adalah bahwa ia mengintegrasikan prinsip-prinsip matematika dari berbagai indikator teknis tradisional, menciptakan sinyal perdagangan yang tunggal dan jelas, menghindari konflik indikator dan sinyal yang membingungkan. Indikator CETP-Plus menyediakan peluang perdagangan multifungsi untuk mengidentifikasi dan menyeimbangkan tren lebih awal melalui perhitungan keteraturan dan keteraturan grafik vertikal tiga dimensi, yang dikombinasikan dengan deviasi kuantitatif, intensitas tren, dan penyesuaian volatilitas.
Meskipun strategi ini memiliki kemampuan beradaptasi dan manajemen risiko yang kuat, namun juga menghadapi tantangan seperti sensitivitas parameter, kompleksitas komputasi, dan perubahan struktur pasar. Dengan menerapkan arah optimasi yang disarankan, seperti mekanisme parameter beradaptasi, analisis multi-frame waktu, dan peningkatan pembelajaran mesin, strategi dapat ditingkatkan lebih lanjut untuk meningkatkan kehandalan dan kinerja jangka panjang.
Secara keseluruhan, ini adalah sistem perdagangan kuantitatif yang dirancang dengan baik dan memiliki dasar teoritis yang kuat, yang cocok untuk digunakan oleh pedagang dengan latar belakang pemrograman dan statistik di pasar yang sangat fluktuatif. Dengan pengoptimalan parameter yang bijaksana dan pemantauan sistematis yang berkelanjutan, strategi ini berpotensi menghasilkan pengembalian yang disesuaikan dengan risiko yang stabil di berbagai lingkungan pasar.
/*backtest
start: 2024-08-11 00:00:00
end: 2025-08-09 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/
// @version=6
strategy("Canuck Trading Traders Strategy [Candle Entropy Edition]", overlay=true, default_qty_value = 10)
// Note: Set Properties "Order size" to "100% of equity" for equity-based sizing or fixed contracts (e.g., 100).
// === CETP-Plus Settings ===
cetp_window = input.int(5, "CETP Window", minval=1, maxval=20, group="CETP-Plus Settings")
cetp_bins = input.int(3, "CETP Bins per Dimension", minval=1, maxval=10, group="CETP-Plus Settings")
long_threshold = input.float(0.1, "Long Threshold", minval=0.01, maxval=5.0, step=0.01, group="CETP-Plus Settings")
short_threshold = input.float(-0.1, "Short Threshold", minval=-0.8, maxval=-0.01, step=0.01, group="CETP-Plus Settings")
cetp_k = input.float(0.8, "CETP Momentum Weight", minval=0.1, maxval=5.0, step=0.1, group="CETP-Plus Settings")
mom_scale = input.float(6.0, "Momentum Scale", minval=1.0, maxval=20.0, step=1.0, group="CETP-Plus Settings")
body_weight = input.float(1.0, "Body Ratio Weight", minval=0.0, maxval=2.0, step=0.1, group="CETP-Plus Settings")
upper_weight = input.float(0.8, "Upper Wick Ratio Weight", minval=0.0, maxval=2.0, step=0.1, group="CETP-Plus Settings")
lower_weight = input.float(1.0, "Lower Wick Ratio Weight", minval=0.0, maxval=2.0, step=0.1, group="CETP-Plus Settings")
decay_factor = 0.8 // Hardcoded decay for exponential weighting (recent candles weighted more)
// === Trade Settings ===
min_score_strength = input.float(0.03, "Min CETP Score Strength", minval=0.0, maxval=5, step=0.01, group="Trade Settings")
stop_loss_pct = input.float(0.5, "Stop Loss (%)", minval=0.1, maxval=5.0, step=0.1, group="Trade Settings")
atr_mult = input.float(3.0, "ATR Multiplier", minval=0.5, maxval=10.0, step=0.1, group="Trade Settings")
trail_mult = input.float(5.0, "Trailing ATR Mult", minval=0.5, maxval=10.0, step=0.1, group="Trade Settings")
trail_offset_pct = input.float(1.0, "Trail Start Offset (%)", minval=0.5, maxval=10.0, step=0.1, group="Trade Settings")
min_price_move_mult = input.float(2.0, "Min Price Move ATR Mult (to avoid tiny trades)", minval=0.5, maxval=10.0, step=0.1, group="Trade Settings") // Filter tiny moves
// Indicators (ATR for stops/trails only)
atr = nz(ta.atr(14), 0.0)
// Volatility Filter (CV < 15% to avoid chop)
vol_threshold = ta.stdev(close, 20) / ta.sma(close, 20) * 100
trade_allowed = vol_threshold < 15.0
// Minimum Price Move Filter (candle range > ATR multiple, floored by min tick)
min_price_move = math.max(atr * min_price_move_mult, syminfo.mintick * 10) // Avoid sub-penny moves; 10x tick for robustness
price_move_condition = (high - low) > min_price_move // Fixed: Use high - low instead of ta.range()
// CETP-Plus Calculation (Blended EMA, RSI, ATR, ADX theses)
epsilon = 1e-5
body_ratio = (close - open) / (high - low + epsilon) * body_weight
upper_wick_ratio = (high - math.max(open, close)) / (high - low + epsilon) * upper_weight
lower_wick_ratio = (math.min(open, close) - low) / (high - low + epsilon) * lower_weight
// EMA-like weighting: Exponentially weight recent candles with fixed-size rolling arrays
var float[] body_arr = array.new_float(cetp_window, 0.0)
var float[] upper_arr = array.new_float(cetp_window, 0.0)
var float[] lower_arr = array.new_float(cetp_window, 0.0)
// Shift and decay older values, add new at the end
for i = 0 to cetp_window - 2
array.set(body_arr, i, array.get(body_arr, i + 1) * decay_factor)
array.set(upper_arr, i, array.get(upper_arr, i + 1) * decay_factor)
array.set(lower_arr, i, array.get(lower_arr, i + 1) * decay_factor)
array.set(body_arr, cetp_window - 1, body_ratio)
array.set(upper_arr, cetp_window - 1, upper_wick_ratio)
array.set(lower_arr, cetp_window - 1, lower_wick_ratio)
// Volatility scaling (ATR thesis)
bin_size = 2.0 / cetp_bins * (1 + atr / ta.sma(atr, 14))
hist_size = cetp_bins * cetp_bins * cetp_bins
var int[] hist = array.new_int(hist_size, 0)
array.fill(hist, 0)
for i = 0 to cetp_window - 1
body_val = array.get(body_arr, i)
upper_val = array.get(upper_arr, i)
lower_val = array.get(lower_arr, i)
body_bin = math.max(0, math.min(cetp_bins - 1, math.floor((body_val + 1) / bin_size)))
upper_bin = math.max(0, math.min(cetp_bins - 1, math.floor((upper_val + 1) / bin_size)))
lower_bin = math.max(0, math.min(cetp_bins - 1, math.floor((lower_val + 1) / bin_size)))
bin_idx = body_bin * (cetp_bins * cetp_bins) + upper_bin * cetp_bins + lower_bin
array.set(hist, bin_idx, array.get(hist, bin_idx) + 1)
entropy = 0.0
for i = 0 to hist_size - 1
count = array.get(hist, i)
p = count / cetp_window
if p > 0
entropy := entropy - p * math.log(p)
max_entropy = math.log(hist_size)
norm_entropy = max_entropy > 0 ? entropy / max_entropy : 0.0
// RSI-like momentum bias
avg_gain = ta.rma(math.max(close - close[1], 0), cetp_window)
avg_loss = ta.rma(math.max(close[1] - close, 0), cetp_window)
rsi_bias = avg_loss > 0 ? avg_gain / avg_loss : 1.0
momentum = ta.mom(close, cetp_window) / (close[cetp_window] != 0 ? close[cetp_window] : 1e-5)
momentum_adj = momentum * (1 + rsi_bias)
// ADX-like trend strength (automated and symmetric for bull/bear)
di_plus = ta.rma(math.max(high - high[1], 0), cetp_window) / atr
di_minus = ta.rma(math.max(low[1] - low, 0), cetp_window) / atr
trend_strength = di_plus > di_minus ? 1.2 : (di_minus > di_plus ? 1.2 : 1.0)
// CETP-Plus Score (optimized: no abs on momentum_adj to preserve sign for better short detection)
avg_body = nz(array.avg(body_arr), 0.0)
raw_score = avg_body * (1 - norm_entropy) * (cetp_k + momentum_adj * mom_scale)
cetp_score = nz(raw_score * trend_strength, 0.0)
// Position State
var float entry_price = na
var int bars_held = 0
if barstate.isconfirmed
bars_held := strategy.position_size != 0 ? bars_held + 1 : 0
// Trade Logic: Rely solely on current CETP score for entries/exits/reversals, with min price move filter
if bar_index >= cetp_window and math.abs(cetp_score) > min_score_strength and trade_allowed and price_move_condition
if cetp_score > long_threshold
if strategy.position_size < 0
strategy.close("Short", comment="Reverse to Long")
if strategy.position_size <= 0
strategy.entry("Long", strategy.long)
entry_price := close
sl = entry_price * (1 - stop_loss_pct / 100) - atr * atr_mult
strategy.exit("Long Exit", "Long", stop=sl, trail_points=atr * trail_mult * syminfo.pointvalue, trail_offset=entry_price * (trail_offset_pct / 100))
bars_held := 1
else if cetp_score < short_threshold
if strategy.position_size > 0
strategy.close("Long", comment="Reverse to Short")
if strategy.position_size >= 0
strategy.entry("Short", strategy.short)
entry_price := close
sl = entry_price * (1 + stop_loss_pct / 100) + atr * atr_mult
strategy.exit("Short Exit", "Short", stop=sl, trail_points=atr * trail_mult * syminfo.pointvalue, trail_offset=entry_price * (trail_offset_pct / 100))
bars_held := 1