Strategi perdagangan kuantitatif pengoptimuman turun naik harga perbezaan rangkaian neural

ATR ANN TANH OHLC4 volatility TIMEFRAME NEURAL NETWORK MACHINE LEARNING
Tarikh penciptaan: 2025-06-23 11:39:44 Akhirnya diubah suai: 2025-06-23 11:39:44
Salin: 5 Bilangan klik: 306
2
fokus pada
319
Pengikut

Strategi perdagangan kuantitatif pengoptimuman turun naik harga perbezaan rangkaian neural Strategi perdagangan kuantitatif pengoptimuman turun naik harga perbezaan rangkaian neural

Gambaran keseluruhan

Strategi perdagangan kuantitatif yang mengoptimumkan turun naik harga perbezaan rangkaian saraf adalah sistem perdagangan frekuensi tinggi berdasarkan rangkaian saraf buatan (ANN) yang direka untuk pengoptimuman jangka masa 1 saat. Strategi ini menggunakan rangkaian saraf untuk menganalisis perbezaan perubahan harga jangka pendek, meramalkan arah harga melalui algoritma penyebaran ke hadapan, dan menggabungkan penapisan kadar turun naik dan kawalan masa sesi untuk mengoptimumkan keputusan perdagangan.

Prinsip Strategi

Strategi ini menggunakan seni bina rangkaian saraf tiga lapisan untuk memproses data perbezaan harga melalui algoritma penyebaran ke hadapan:

  1. Lapisan Input (L0): Peratusan perbezaan antara OHLC4 semasa () dan jangka masa rujukan () OHLC4 sejarah sebagai satu input neuron.

  2. Lapisan tersembunyi pertama (L1): Mempunyai 5 neuron, menggunakan tanh sebagai fungsi pengaktifan, untuk mengubah input data secara tidak linear. Setiap neuron mempunyai berat yang dilatih terlebih dahulu, untuk mod tertentu untuk menangkap perbezaan harga.

  3. Lapisan tersembunyi kedua (L2): mengandungi 33 neuron, juga menggunakan fungsi pengaktifan tanh, untuk memproses lebih lanjut output lapisan tersembunyi pertama melalui matriks berat yang lebih kompleks.

  4. Lapisan Keluaran (L3): Satu neuron mengeluarkan isyarat ramalan akhir, yang nilainya dibalikkan untuk membetulkan arah isyarat.

Logik urus niaga berkisar pada nilai output rangkaian saraf ((L3_0):

  • Apabila L3_0 lebih besar daripada had kemasukan ((default 0.003), isyarat multitasking dicetuskan
  • Apabila L3_0 lebih kecil daripada had masuk negatif ((-0.003), mencetuskan isyarat kosong
  • Apabila L3_0 lebih kecil daripada had keluar ((default 0.001), kedudukan kosong
  • Apabila L3_0 lebih besar daripada had keluar negatif ((-0.001), kedudukan kosong kosong

Strategi ini juga mewujudkan tiga mekanisme penapisan:

  • Penapis tempoh penyejukan: Selepas transaksi dijalankan, sistem terpaksa menunggu tempoh penyejukan yang ditetapkan (default 60 detik)
  • Penapis kadar turun naik: Melalui ATR ((Average True Range) penunjuk, hanya berdagang apabila turun naik pasaran melebihi paras paras minimum ((default 0.02)
  • Penapisan masa transaksi: boleh memilih untuk mengehadkan dagangan hanya pada waktu pasaran tertentu (default 9:00-16:00)

Kelebihan Strategik

  1. Keupayaan untuk meramalkan dengan tepatStruktur pelbagai lapisan rangkaian saraf dapat menangkap hubungan bukan linear yang kompleks dalam pergerakan harga, yang sukar untuk dicapai oleh penunjuk teknologi tradisional. Struktur ini dapat mengenali corak harga jangka pendek, terutama dalam persekitaran frekuensi tinggi, dan memberikan isyarat masuk dan keluar yang lebih tepat.

  2. Rasio risiko dan ganjaran yang cemerlangStrategi ini mencapai faktor keuntungan 3.754, yang bermaksud jumlah dagangan yang menguntungkan adalah 3.754 kali jumlah dagangan yang rugi, yang merupakan prestasi yang sangat baik dalam strategi kuantitatif.

  3. Ruang optimasi parameter yang fleksibelStrategi ini menyediakan pelbagai parameter yang boleh disesuaikan, termasuk had masuk / keluar, panjang tempoh penyejukan, bingkai masa rujukan dan keperluan kadar turun naik minimum, yang membolehkan peniaga mengoptimumkan mengikut keadaan pasaran dan jenis perdagangan yang berbeza.

  4. Mekanisme penapisan berbilangStrategi ini berkesan mengurangkan perdagangan yang tidak perlu dan isyarat palsu, meningkatkan kualiti perdagangan dengan menggabungkan tempoh sejuk, turun naik dan penapisan tiga kali pada masa perdagangan.

  5. Sesuaikan diri dengan persekitaran perdagangan frekuensi tinggi: Optimum untuk jangka masa 1 saat, yang dapat memanfaatkan ciri-ciri perdagangan frekuensi tinggi untuk menangkap peluang keuntungan dari turun naik harga jangka pendek.

  6. Low latencyStruktur kod strategi jelas dan cekap, bahagian rangkaian saraf menggunakan berat pra-latihan untuk pengiraan langsung, tanpa latihan masa nyata, memastikan pelaksanaan latensi rendah dalam persekitaran frekuensi tinggi.

Risiko Strategik

  1. Risiko terlalu serasiModel rangkaian saraf mengandungi banyak parameter berat prasetel, dengan risiko over-fit untuk data sejarah. Ini boleh menyebabkan strategi tidak berfungsi dengan baik dalam perdagangan langsung, terutamanya apabila keadaan pasaran berubah dengan ketara.

  2. Kepekaan ParameterPrestasi strategi sangat bergantung kepada beberapa tetapan parameter, seperti ambang masuk / keluar, panjang tempoh penyejukan, dan lain-lain. Perubahan kecil dalam parameter boleh menyebabkan perubahan besar dalam prestasi strategi. Adalah disyorkan untuk mencari kombinasi parameter yang stabil melalui imbasan parameter dan ujian langkah demi langkah, dan mengelakkan pengoptimuman berlebihan.

  3. Risiko perdagangan frekuensi tinggiPada jangka masa 1 saat, kos dagangan (seperti titik selisih dan titik slippage) boleh memberi kesan kepada keuntungan strategi. Kos ini harus dipertimbangkan sepenuhnya sebelum berdagang secara langsung, dan memodelkan keadaan kos dagangan sebenar dalam tinjauan balik.

  4. Cabaran Mencapai TeknologiStrategi frekuensi tinggi memerlukan sistem perdagangan yang mempunyai kelewatan yang sangat rendah dan kebolehpercayaan yang tinggi. Mana-mana kelewatan rangkaian, kelewatan data atau kelewatan pelaksanaan boleh menyebabkan kegagalan strategi.

  5. Risiko turun naik pasaranDalam keadaan pasaran yang melampau, model rangkaian saraf mungkin tidak dapat meramalkan pergerakan harga dengan tepat, menyebabkan kerugian yang besar. Ia disyorkan untuk menetapkan langkah-langkah hentian dan had kerugian harian maksimum, dan menangguhkan strategi semasa turun naik yang melampau.

Arah pengoptimuman strategi

  1. Pengoptimuman seni bina rangkaian saraf:

    • Pertimbangkan untuk memperkenalkan lebih banyak ciri input, seperti jumlah transaksi, indikator kadar turun naik, dan indikator pergerakan harga, untuk meningkatkan kemampuan ramalan model
    • Bereksperimen dengan struktur lapisan tersembunyi yang berbeza dan bilangan neuron untuk mencari keseimbangan terbaik antara kerumitan dan keupayaan untuk meluas
    • Meneroka kesan fungsi pengaktifan lain (seperti ReLU atau Leaky ReLU) yang lebih baik daripada tanh dalam aplikasi rangkaian saraf tertentu
  2. Mekanisme penyesuaian parameter dinamik:

    • Memperolehi penyesuaian masuk/keluar yang sesuai dengan keadaan pasaran, contohnya, penyesuaian penyesuaian dalam keadaan turun naik yang tinggi dan penyesuaian dalam keadaan turun naik yang rendah
    • Membangunkan algoritma penyesuaian tempoh sejuk yang mengesan turun naik, membolehkan strategi untuk mengekalkan frekuensi dagangan yang optimum pada peringkat pasaran yang berbeza
  3. Kerangka Ramalan Bersepadu:

    • Model rangkaian saraf yang digabungkan dengan pelbagai bingkai masa untuk membentuk isyarat ramalan komprehensif
    • Memperkenalkan metamodel pembelajaran mesin untuk menyesuaikan berat model ramalan yang berbeza secara dinamik
    • Kaedah ini dapat mengurangkan keterbatasan model tunggal dan meningkatkan kestabilan ramalan.
  4. Pengurusan risiko yang lebih baik:

    • Membangunkan sistem pengurusan kedudukan dinamik untuk menyesuaikan skala dagangan mengikut keyakinan model dan keadaan pasaran
    • Memperkenalkan strategi stop loss berasaskan pembelajaran mesin untuk mengoptimumkan nisbah risiko dan ganjaran bagi setiap dagangan
    • Untuk mencapai optimasi masa dalam sehari, mengenal pasti masa strategi yang terbaik dalam sehari
  5. Pembelajaran dan penyesuaian dalam masa nyata:

    • Reka bentuk mekanisme pembelajaran dalam talian yang membolehkan rangkaian saraf terus belajar dari data baru dan menyesuaikan diri dengan perubahan pasaran
    • Mempunyai pemicu latihan semula automatik berdasarkan pemantauan prestasi, yang secara aktif mengemas kini model apabila prestasi strategi menurun
    • Kaedah ini dapat meningkatkan jangka hayat dan kestabilan strategi dengan ketara.

ringkaskan

Strategi perdagangan kuantitatif yang mengoptimumkan turun naik harga perbezaan rangkaian saraf mewakili amalan terdepan dalam perdagangan kuantitatif moden, yang berjaya menggunakan teknologi rangkaian saraf buatan dalam bidang perdagangan frekuensi tinggi. Dengan struktur rangkaian saraf berlapis yang dirancang dengan teliti, strategi ini dapat menangkap corak halus dalam perubahan harga jangka pendek dan meningkatkan kualiti perdagangan melalui mekanisme penapisan berganda.

Faktor keuntungan 3.754 membuktikan bahawa strategi ini berfungsi dengan baik dalam persekitaran ujian, tetapi penggunaan praktikal masih perlu mempertimbangkan risiko yang berkaitan dengan overfit, sensitiviti parameter dan perdagangan frekuensi tinggi. Dengan terus mengoptimumkan seni bina rangkaian saraf, mewujudkan penyesuaian parameter dinamik dan meningkatkan pengurusan risiko, strategi ini berpotensi untuk kekal kompetitif dalam jangka panjang dalam bidang perdagangan kuantitatif yang kompetitif.

Faktor kejayaan utama strategi ini adalah menggabungkan teknologi rangkaian saraf yang kompleks dengan logik perdagangan yang praktikal, yang memanfaatkan kemampuan ramalan pembelajaran mesin dan mempertimbangkan kebolehan perdagangan sebenar. Bagi pedagang kuantitatif yang berpengalaman, ini memberikan kerangka kerja yang boleh diperluas untuk menyesuaikan dan mengoptimumkan lebih lanjut mengikut pasaran yang berbeza dan pilihan risiko peribadi.

Kod sumber strategi
/*backtest
start: 2024-06-23 00:00:00
end: 2025-06-21 08:00:00
period: 2h
basePeriod: 2h
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

//@version=5
strategy("ANN Strategy v2 (Optimized for 1s)", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// === INPUTS ===
entryThreshold = input.float(0.003, title="Entry Threshold")
exitThreshold  = input.float(0.001, title="Exit Threshold")
cooldownBars   = input.int(60, title="Cooldown (bars)")  // 60 seconds cooldown
timeframe      = input.timeframe("1", title="Reference Timeframe")  // 1-minute diff reference
minVolatility  = input.float(0.02, title="Min ATR (Volatility Filter)")
useSession     = input.bool(true, title="Use Session Filter")

// === UTILITY FUNCTIONS ===
getDiff() =>
    prev = request.security(syminfo.tickerid, timeframe, ohlc4[1])
    now = ohlc4
    (now - prev) / prev

linear(v) => v
tanh(v) => (math.exp(v) - math.exp(-v)) / (math.exp(v) + math.exp(-v))

// === ANN FORWARD PROPAGATION ===
l0_0 = linear(getDiff())

l1 = array.new_float()
array.push(l1, tanh(l0_0 * 0.8446488687))
array.push(l1, tanh(l0_0 * -0.5674069006))
array.push(l1, tanh(l0_0 * 0.8676766445))
array.push(l1, tanh(l0_0 * 0.5200611473))
array.push(l1, tanh(l0_0 * -0.2215499554))

// === Layer 2 weights ===
w2 = array.from(    0.3341657935, -2.0060003664, 0.8606354375, 0.9184846912, -0.8531172267,    -0.0394076437, -0.4720374911, 0.2900968524, 1.0653326022, 0.3000188806,    -0.559307785, -0.9353655177, 1.2133832962, 0.1952686024, 0.8552068166,    -0.4293220754, 0.8484259409, -0.7154087313, 0.1102971055, 0.2279392724,    0.9111779155, 0.2801691115, 0.0039982713, -0.5648257117, 0.3281705155,    -0.2963954503, 0.4046532178, 0.2460580977, 0.6608675819, -0.8732022547,    0.8810811932, 0.6903706878, -0.5953059103, -0.3084040686, -0.4038498853,    -0.5687101164, 0.2736758588, -0.2217360382, 0.8742950972, 0.2997583987,    0.0708459913, 0.8221730616, -0.7213265567, -0.3810462836, 0.0503867753,    0.4880140595, 0.9466627196, 1.0163097961, -0.9500386514, -0.6341709382,    1.3402207103, 0.0013395288, 3.4813009133, -0.8636814677, 41.3171047132,    1.2388217292, -0.6520886912, 0.3508321737, 0.6640560714, 1.5936220597,    -0.1800525171, -0.2620989752, 0.056675277, -0.5045395315, 0.2732553554,    -0.7776331454, 0.1895231137, 0.5384918862, 0.093711904, -0.3725627758,    -0.3181583022, 0.2467979854, 0.4341718676, -0.7277619935, 0.1799381758,    -0.5558227731, 0.3666152536, 0.1538243225, -0.8915928174, -0.7659355684,    0.6111516061, -0.5459495224, -0.5724238425, -0.8553500765, -0.8696190472,    0.6843667454, 0.408652181, -0.8830470112, -0.8602324935, 0.1135462621,    -0.1569048216, -1.4643247888, 0.5557152813, 1.0482791924, 1.4523116833,    0.5207514017, -0.2734444192, -0.3328660936, -0.7941515963, -0.3536051491,    -0.4097807954, 0.3198619826, 0.461681627, -0.1135575498, 0.7103339851,    -0.8725014237, -1.0312091401, 0.2267643037, -0.6814258121, 0.7524828703,    -0.3986855003, 0.4962556631, -0.7330224516, 0.7355772164, 0.3180141739,    -1.083080442, 1.8752543187, 0.3623326265, -0.348145191, 0.1977935038,    -0.0291290625, 0.0612906199, 0.1219696687, -1.0273685429, 0.0872219768,    0.931791094, -0.313753684, -0.3028724837, 0.7387076712, 0.3806140391,    0.2630619402, -1.9827996702, -0.7741413496, 0.1262957444, 0.2248777886,    -0.2666322362, -1.124654664, 0.7288282621, -0.1384289204, 0.2395966188,    0.6611845175, 0.0466048937, -0.1980999993, 0.8152350927, 0.0032723211,    -0.3150344751, 0.1391754608, 0.5462816249, -0.7952302364, -0.7520712378,    -0.0576916066, 0.3678415302, 0.6802537378, 1.1437036331, -0.8637405666,    0.7016273068, 0.3978601709, 0.3157049654, -0.2528455662, -0.8614146703,    1.1741126834, -1.4046408959, 1.2914477803, 0.9904052964, -0.6980155826)


l2 = array.new_float()
for i = 0 to 32
    sum = 0.0
    for j = 0 to 4
        weight = array.get(w2, i * 5 + j)
        sum += weight * array.get(l1, j)
    array.push(l2, tanh(sum))

// === Output layer weights ===
weights_out = array.from(    -0.1366382003, 0.8161960822, -0.9458773183, 0.4692969576, 0.0126710629,    -0.0403001012, -0.0116244898, -0.4874816289, -0.6392241448, -0.410338398,    -0.1181027081, 0.1075562037, -0.5948728252, 0.5593677345, -0.3642935247,    -0.2867603217, 0.142250271, -0.0535698019, -0.034007685, -0.3594532426,    0.2551095195, 0.4214344983, 0.8941621336, 0.6283377368, -0.7138020667,    -0.1426738249, 0.172671223, 0.0714824385, -0.3268182144, -0.0078989755,    -0.2032828145, -0.0260631534, 0.4918037012)


sum_out = 0.0
for i = 0 to array.size(l2) - 1
    sum_out += array.get(weights_out, i) * array.get(l2, i)

// === Final ANN output (inverted for signal correction) ===
l3_0 = -tanh(sum_out)

// === TRADE FILTERS ===
volatility = ta.atr(14)
isVolOkay = volatility > minVolatility

isSession = (hour >= 9 and hour < 16)  // Adjust to your market hours
sessionOkay = useSession ? isSession : true

// === SIGNAL LOGIC ===
var string activeTrade = "none"
var int lastTradeBar = na
canTrade = (na(lastTradeBar) or (bar_index - lastTradeBar > cooldownBars)) and isVolOkay and sessionOkay

enterLong  = l3_0 > entryThreshold  and activeTrade != "long"  and canTrade
exitLong   = l3_0 < exitThreshold   and activeTrade == "long"
enterShort = l3_0 < -entryThreshold and activeTrade != "short" and canTrade
exitShort  = l3_0 > -exitThreshold  and activeTrade == "short"

// === STRATEGY EXECUTION ===
if barstate.isrealtime
    if enterLong
        strategy.entry("Long", strategy.short)
        activeTrade := "long"
        lastTradeBar := bar_index

    if exitLong
        strategy.close("Long")
        activeTrade := "none"

    if enterShort
        strategy.entry("Short", strategy.long)
        activeTrade := "short"
        lastTradeBar := bar_index

    if exitShort
        strategy.close("Short")
        activeTrade := "none"

// === PLOTTING ===
bgcolor(activeTrade == "long" ? color.new(color.green, 85) : activeTrade == "short" ? color.new(color.red, 85) : na)
plot(l3_0, title="ANN Output (Inverted)", color=color.aqua, linewidth=2)