1. スクエア
  2. これは実験的な量的な取引戦略です

これは実験的な量的な取引戦略です

作者: リン・ハーンチャオチャン開催日:2023年12月22日 14:13:27
タグ:

img

概要

これは,移動平均指標とkNN機械学習アルゴリズムを組み合わせて取引信号を生成する実験的定量取引戦略である.トレンド方向を決定するために異なる期間の2つのVWMAラインのクロスオーバーを使用し,信号の信頼性を向上させるために,kNNアルゴリズムを通じて信号をフィルタリングするためにMFIとADX指標を使用する.

戦略の原則

この戦略のコア指標は,2つの異なるパラメータを持つVWMAラインである,すなわち高速線とスローラインである.高速線がスローラインを越えたとき,購入信号が生成される.高速線がスローラインを下回ったとき,販売信号が生成される.さらに,この戦略は,現在の市場状況下で現在の信号の信頼性を判断するために,MFIとADXという2つの補助指標を導入する.

kNNアルゴリズムの背後にあるアイデアは,新しいデータを過去データと比較して,最も似た過去データに匹敵する結果を決定し,これらの過去結果の多数投票に基づいて分類することです.この戦略は,この指標の組み合わせの下で歴史的な価格動き (上昇傾向または下落傾向) を決定するために,kNNアルゴリズムの2つの入力パラメータとしてMFIとADXを使用し,それによって現在の信号をフィルタリングして信号品質を改善します.

利点

  • VWMAのトレンドフォロー能力を活用し,移動平均クロスオーバーを通じて取引信号を生成する
  • 動向の方向性を決定するのに役立つ多次元的な特徴抽出のために,MFIとADX指標を適用する
  • kNN機械学習アルゴリズムを活用して,ダイナミックな取引信号を最適化しフィルタリングする
  • より多くのデータ検証と最適化によって改善の余地のある実験戦略

リスクと緩和策

  • VWMAラインは遅れている
  • 市場情勢を誤って判断する可能性があります.
  • kNN アルゴリズムパラメータ (k値など) は結果に大きな影響を与える.
  • 実験的戦略は,ライブ取引では劣る可能性があります.

緩和策

  • 遅延を減らすために MA パラメータを調整する
  • 傾向をより正確に判断するための指標の改善
  • kNNパラメータを最適化してフィットネスを改善する
  • バックテストや紙取引による戦略の検証

オプティマイゼーションの方向性

この戦略を最適化するには大きな余地があります.

  • MAの組み合わせを構成するために,より多くのMA指標を追加します.
  • MACD,KDJなど,他の補助指標を試してください.
  • kNN アルゴリズムを改良する.例えば,異なる距離メトリックを使用する
  • SVM,ランダムフォレストなど
  • 最適なパラメータセットを見つけるためにパラメータ調節

より多くの指標と機械学習アルゴリズムを導入することで 戦略の安定性と収益性がさらに向上する可能性があります

概要

これは,VWMA指標とkNN機械学習アルゴリズムに基づいた実験的定量的な取引戦略である.機械学習を通じてシグナルをフィルタリングする際に強いトレンドフォロー能力の利点がある.この戦略は,より良い結果のためのより多くの機能と最適化アルゴリズムを導入することによって拡大する余地が大きい.しかし,新しい戦略として,さらなる検証と改善を必要とするリスクも存在する.全体的にこの戦略は大きなイノベーションの可能性を持っている.

/*backtest
start: 2023-11-21 00:00:00
end: 2023-12-21 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © lastguru

//@version=4
strategy(title="VWMA with kNN Machine Learning: MFI/ADX", shorttitle="VWMA + kNN: MFI/ADX", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

/////////
// kNN //
/////////

// Define storage arrays for: parameter 1, parameter 2, price, result (up = 1; down = -1)
var knn1 = array.new_float(1, 0)
var knn2 = array.new_float(1, 0)
var knnp = array.new_float(1, 0)
var knnr = array.new_float(1, 0)

// Store the previous trade; buffer the current one until results are in
_knnStore (p1, p2, src) =>
    var prevp1 = 0.0
    var prevp2 = 0.0
    var prevsrc = 0.0
    
    array.push(knn1, prevp1)
    array.push(knn2, prevp2)
    array.push(knnp, prevsrc)
    array.push(knnr, src >= prevsrc ? 1 : -1)
    
    prevp1 := p1
    prevp2 := p2
    prevsrc := src

// Sort two arrays (MUST be of the same size) based on the first.
// In other words, when an element in the first is moved, the element in the second moves as well.
_knnGet(arr1, arr2, k) =>
    sarr = array.copy(arr1)
    array.sort(sarr)
    ss = array.slice(sarr, 0, min(k, array.size(sarr)))
    m = array.max(ss)
    out = array.new_float(0)
    for i = 0 to array.size(arr1) - 1
        if (array.get(arr1, i) <= m)
            array.push(out, array.get(arr2, i))
    out

// Create a distance array from the two given parameters
_knnDistance(p1, p2) =>
    dist = array.new_float(0)
    n = array.size(knn1) - 1
    for i = 0 to n
        d = sqrt( pow(p1 - array.get(knn1, i), 2) + pow(p2 - array.get(knn2, i), 2) )
        array.push(dist, d)
    dist

// Make a prediction, finding k nearest neighbours
_knn(p1, p2, k) =>
    slice = _knnGet(_knnDistance(p1, p2), array.copy(knnr), k)
    knn = array.sum(slice)

////////////
// Inputs //
////////////

SRC = input(title="Source", type=input.source, defval=open)
FAST = input(title="Fast Length", type=input.integer, defval=13)
SLOW = input(title="Slow Length", type=input.integer, defval=19)
FILTER = input(title="Filter Length", type=input.integer, defval=13)
SMOOTH = input(title="Filter Smoothing", type=input.integer, defval=6)
KNN = input(title="kNN nearest neighbors (k)", type=input.integer, defval=23)
BACKGROUND = input(false,title = "Draw background")

////////
// MA //
////////
fastMA = vwma(SRC, FAST)
slowMA = vwma(SRC, SLOW)

/////////
// DMI //
/////////

// Wilder's Smoothing (Running Moving Average)
_rma(src, length) =>
    out = 0.0
    out := ((length - 1) * nz(out[1]) + src) / length

// DMI (Directional Movement Index)
_dmi (len, smooth) =>
    up = change(high)
    down = -change(low)
    plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
    minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
    trur = _rma(tr, len)
    plus = fixnan(100 * _rma(plusDM, len) / trur)
    minus = fixnan(100 * _rma(minusDM, len) / trur)
    sum = plus + minus
    adx = 100 * _rma(abs(plus - minus) / (sum == 0 ? 1 : sum), smooth)
    [plus, minus, adx]

[diplus, diminus, adx] = _dmi(FILTER, SMOOTH)

/////////
// MFI //
/////////

// common RSI function
_rsi(upper, lower) =>
    if lower == 0
        100
    if upper == 0
        0
	100.0 - (100.0 / (1.0 + upper / lower))

mfiUp = sum(volume * (change(ohlc4) <= 0 ? 0 : ohlc4), FILTER)
mfiDown = sum(volume * (change(ohlc4) >= 0 ? 0 : ohlc4), FILTER)
mfi = _rsi(mfiUp, mfiDown)

////////////
// Filter //
////////////

longCondition = crossover(fastMA, slowMA)
shortCondition = crossunder(fastMA, slowMA)

if (longCondition or shortCondition)
    _knnStore(adx, mfi, SRC)
filter = _knn(adx, mfi, KNN)

/////////////
// Actions //
/////////////

bgcolor(BACKGROUND ? filter >= 0 ? color.green : color.red : na)
plot(fastMA, color=color.red)
plot(slowMA, color=color.green)

if (longCondition and filter >= 0)
    strategy.entry("Long", strategy.long)
if (shortCondition and filter < 0)
    strategy.entry("Short", strategy.short)
もっと

2019 FMZ - すべての権利は保護されています.