Sumber daya yang dimuat... Pemuatan...

Tren Parameter Adaptif Berbasis KNN Mengikuti Strategi

Penulis:ChaoZhang, Tanggal: 2024-11-29 10:54:49
Tag:MAKNNSMA

Gambaran umum

Strategi ini adalah sistem mengikuti tren parametrik adaptif berdasarkan algoritma pembelajaran mesin K-Nearest Neighbors (KNN). Strategi ini secara dinamis menyesuaikan tren mengikuti parameter melalui algoritma KNN dan menghasilkan sinyal perdagangan dalam kombinasi dengan moving average. Sistem dapat secara otomatis menyesuaikan parameter strategi berdasarkan perubahan kondisi pasar, meningkatkan kemampuan beradaptasi dan stabilitas strategi. Strategi ini menggabungkan metode pembelajaran mesin untuk mengoptimalkan strategi mengikuti tren tradisional, mewakili perpaduan teknologi dan inovasi dalam investasi kuantitatif.

Prinsip Strategi

Prinsip inti dari strategi ini adalah untuk menganalisis data harga historis menggunakan algoritma KNN dan memprediksi tren harga dengan menghitung kesamaan antara kondisi pasar saat ini dan data historis.

Atur ukuran jendela pengamatan dan nilai K, kumpulkan data harga historis untuk membentuk vektor fitur
Hitung jarak Euclidean antara urutan harga saat ini dan data historis
Pilih K urutan harga historis yang paling mirip sebagai sampel tetangga
Menganalisis pergerakan harga berikutnya dari sampel tetangga K ini
Menghasilkan sinyal perdagangan berdasarkan perubahan harga rata-rata dari sampel tetangga dikombinasikan dengan rata-rata bergerak Ketika perubahan harga rata-rata dari sampel tetangga K positif dan harga saat ini di atas rata-rata bergerak, sistem menghasilkan sinyal panjang; jika tidak, itu menghasilkan sinyal pendek.

Keuntungan Strategi

Kemampuan beradaptasi yang kuat: Algoritma KNN dapat menyesuaikan parameter secara otomatis berdasarkan perubahan lingkungan pasar
Analisis multi-dimensi: Menggabungkan algoritma pembelajaran mesin dan indikator teknis untuk analisis pasar yang lebih komprehensif
Pengendalian risiko yang wajar: Menggunakan rata-rata bergerak sebagai konfirmasi tambahan untuk mengurangi dampak sinyal palsu
Logika komputasi yang jelas: Proses pelaksanaan strategi transparan dan mudah dipahami dan dioptimalkan
Parameter fleksibel: Nilai K dan ukuran jendela dapat disesuaikan sesuai dengan lingkungan pasar yang berbeda

Risiko Strategi

Kompleksitas komputasi yang tinggi: Algoritma KNN membutuhkan perhitungan sejumlah besar data historis
Sensitivitas parameter: Pilihan nilai K dan ukuran jendela berdampak signifikan pada kinerja strategi
Ketergantungan lingkungan pasar: Nilai referensi kesamaan historis dapat menurun di pasar yang volatile
Risiko overfitting: ketergantungan yang berlebihan pada data historis dapat menyebabkan overfitting strategi
Risiko keterlambatan: Keterlambatan sinyal mungkin ada karena kebutuhan untuk pengumpulan data historis yang cukup

Arah Optimasi Strategi

Optimasi Teknik Fitur:

Tambahkan lebih banyak indikator teknis sebagai fitur
Memperkenalkan indikator sentimen pasar
Mengoptimalkan metode standardisasi fitur

Peningkatan efisiensi algoritma:

Mengoptimalkan pencarian tetangga terdekat menggunakan pohon KD
Mengimplementasikan komputasi paralel
Mengoptimalkan metode penyimpanan dan akses data

Peningkatan Kontrol Risiko:

Tambahkan mekanisme stop loss dan take profit
Memperkenalkan filter volatilitas
Desain sistem manajemen posisi dinamis

Solusi Optimasi Parameter:

Menerapkan pilihan nilai K adaptif
Sesuaikan ukuran jendela pengamatan secara dinamis
Mengoptimalkan periode rata-rata bergerak

Peningkatan mekanisme pembuatan sinyal:

Memperkenalkan sistem penilaian kekuatan sinyal
Mekanisme konfirmasi sinyal desain
Optimalkan waktu masuk dan keluar

Ringkasan

Strategi ini secara inovatif menerapkan algoritma KNN untuk mengikuti tren perdagangan, mengoptimalkan strategi analisis teknis tradisional melalui metode pembelajaran mesin. Strategi ini memiliki kemampuan beradaptasi dan fleksibilitas yang kuat, mampu menyesuaikan parameter secara dinamis berdasarkan kondisi pasar. Meskipun risiko seperti kompleksitas komputasi tinggi dan sensitivitas parameter ada, strategi ini masih memiliki nilai aplikasi yang baik melalui optimasi yang wajar dan langkah-langkah pengendalian risiko.

/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-31 23:59:59
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=6
strategy("Trend Following Strategy with KNN", overlay=true,commission_value=0.03,currency='USD', commission_type=strategy.commission.percent,default_qty_type=strategy.cash)


// Input parameters
k = input.int(5, title="K (Number of Neighbors)", minval=1)  // Number of neighbors for KNN algorithm
window_size = input.int(20, title="Window Size", minval=1)  // Window size for feature vector calculation
ma_length = input.int(50, title="MA Length", minval=1)  // Length of the moving average

// Calculate moving average
ma = ta.sma(close, ma_length)

// Initialize variables
var float[] features = na
var float[] distances = na
var int[] nearest_neighbors = na

if bar_index >= window_size - 1  // Ensure there is enough historical data
    features := array.new_float(0)  // Keep only the current window data
    for i = 0 to window_size - 1
        array.push(features, close[i])

    // Calculate distances
    distances := array.new_float(0)  // Clear the array for each calculation
    for i = 0 to window_size - 1  // Calculate the distance between the current price and all prices in the window
        var float distance = 0.0
        for j = 0 to window_size - 1
            distance += math.pow(close[j] - array.get(features, j), 2)
        distance := math.sqrt(distance)
        array.push(distances, distance)

    // Find the nearest neighbors
    if array.size(distances) > 0 and array.size(distances) >= k
        nearest_neighbors := array.new_int(0)
        for i = 0 to k - 1
            var int min_index = -1
            var float min_distance = na
            for j = 0 to array.size(distances) - 1
                if na(min_distance) or array.get(distances, j) < min_distance
                    min_index := j
                    min_distance := array.get(distances, j)
            if min_index != -1
                array.push(nearest_neighbors, min_index)
                array.remove(distances, min_index)  // Remove the processed neighbor

    // Calculate the average price change of the neighbors
    var float average_change = 0.0
    if array.size(nearest_neighbors) > 0
        for i = 0 to array.size(nearest_neighbors) - 1
            var int index = array.get(nearest_neighbors, i)
            // Ensure index + 1 is within range
            if index + 1 < bar_index
                average_change += (close[index] - close[index + 1])
        average_change := average_change / array.size(nearest_neighbors)

    // Generate trading signals
    if average_change > 0 and close > ma
        strategy.entry("Long", strategy.long)
    else if average_change < 0 and close < ma
        strategy.entry("Short", strategy.short)

Berkaitan

Lebih banyak

2019 FMZ - Semua hak dilindungi