Dynamisches Netz-Trend-nachfolgender quantitativer Handelsstrategie

Schriftsteller:ChaoZhang, Datum: 2024-03-22 16:03:09
Tags:

img

Übersicht

Dies ist eine fortschrittliche dynamische Netztrend-nachfolgende quantitative Handelsstrategie. Die Hauptidee dieser Strategie besteht darin, mehrere Netzlinien innerhalb einer vorgegebenen Preisspanne zu teilen und automatisch Positionen zu eröffnen, wenn der Preis die Netzlinien erreicht und Positionen beim Verkauf zu schließen, wodurch von schwankenden Märkten profitiert wird. Gleichzeitig hat diese Strategie auch die Funktion, die Position der Netzlinien dynamisch anzupassen, die das Netzlayout anpassungsfähig nach den jüngsten Preistrends optimieren kann.

Strategieprinzip

Die Grundprinzipien dieser Strategie sind folgende:

  1. Erstens werden die oberen und unteren Grenzen des Rasters und die Anzahl der Rasterlinien basierend auf den Einstellungen des Benutzers bestimmt.

  2. Innerhalb der festgelegten Grenzen teilen Sie die Preisspanne in mehrere Gitter. Jede Gitterlinie entspricht einem Kauf- oder Verkaufspreis.

  3. Wenn der Preis jede Gitterlinie erreicht, überprüft die Strategie, ob die Position, die der Gitterlinie entspricht, bereits gehalten wird. Falls nicht, öffnet sie eine Position und kauft, wenn ja, schließt sie die Position und verkauft.

  4. Durch den Verkauf an relativ hohen Positionen und den Kauf an niedrigen Positionen kann die Strategie bei Preisschwankungen kontinuierlich profitieren.

  5. Gleichzeitig wird, wenn der Benutzer die automatische Grenzregelungsfunktion aktiviert, die Position der Gitterlinien anpassungsfähig nach den jüngsten Preishochs und -tiefs oder dem eingestellten gleitenden Durchschnitt angepasst, um das Gitterlayout zu optimieren.

Durch die oben genannten Prinzipien kann diese Strategie automatisch niedrige Käufe und hohe Verkäufe bei schwankenden Preistrends realisieren und Gewinnpunkte entsprechend den Trends anpassen und so die Gesamtrendite verbessern.

Analyse der Vorteile

Diese dynamische Netzstrategie hat folgende Vorteile:

  1. Starke Anpassungsfähigkeit: Sie kann sich durch Parametereinstellungen an verschiedene Märkte und Sorten anpassen und ist gut anpassungsfähig an schwankende Märkte.

  2. Da die Strategie auf einer strengen mathematischen Logik und klaren Positionseröffnungs- und -schließpunkten basiert, kann sie einen vollautomatisierten Handel erreichen und subjektive emotionale Interferenzen reduzieren.

  3. Kontrollierbares Risiko: Durch die Festlegung von Parametern wie der Anzahl der Netze und der Netzgrenzen kann das Risikopositionsniveau jeder Transaktion wirksam kontrolliert werden, wodurch das Gesamtrisiko in einem akzeptablen Bereich gehalten wird.

  4. Anpassungsfähigkeit an den Trend: Die Funktion der dynamischen Anpassung der Netzgrenzen wird der Strategie hinzugefügt, so dass das Netz den Preistrends folgen und optimiert werden kann, wodurch die Rentabilität in Trendmärkten verbessert wird.

  5. Da der Netthandel im Wesentlichen häufig ist und hohe und niedrige Preisschwankungen anzieht, kann diese Strategie weiterhin profitieren, so dass sie langfristig eine hohe Gewinnrate hat.

Risikoanalyse

Obwohl diese Strategie offensichtliche Vorteile hat, birgt sie auch gewisse Risiken:

  1. Wenn der Preis mit einem starken einseitigen Trend durch die Gittergrenze bricht, ist der Gewinnraum dieser Strategie begrenzt und es kann zu einem großen Rückschritt kommen.

  2. Schwierigkeiten bei der Optimierung von Parametern. Diese Strategie hat viele Parameter, darunter die Anzahl der Gitter, Anfangsgrenzen, dynamische Grenzparameter usw. Verschiedene Parameterkombinationen haben einen großen Einfluss auf die Strategieleistung, und die tatsächliche Optimierungsschwierigkeit ist nicht gering.

  3. Häufiger Handel: Die Netzstrategie ist im Wesentlichen eine Hochfrequenzstrategie mit sehr häufiger Eröffnung und Schließung von Positionen, was zu höheren Transaktionskosten und potenziellen Risiken bei Schlüpfen führt.

  4. Diese Strategie ist stark von schwankenden Märkten abhängig. Sobald der Preis in einen schnellen einseitigen Trend eintritt, wird diese Strategie wahrscheinlich einem großen Rückschritt ausgesetzt sein.

Angesichts dieser Risiken können Verbesserungen in folgenden Bereichen vorgenommen werden: Hinzufügen von Trendbeurteilungsindikatoren als Filterbedingungen für die Strategieentwicklung, Optimierung des Parametersuchraums und -methoden, Einführung von Fondsmanagement- und Positionskontrolllogik, Erhöhung der Trenddurchbruchschließlogik usw. Durch diese Optimierungen können die Robustheit und Rentabilität dieser Strategie weiter verbessert werden.

Optimierungsrichtung

Auf der Grundlage der vorstehenden Analyse umfassen die Optimierungsrichtungen dieser Strategie hauptsächlich:

  1. Einführung von Trendfilterbedingungen. Hinzufügen von Trendbeurteilungsindikatoren, bevor die Strategie beginnt, wie beispielsweise gleitende Durchschnitte, ADX usw. Starten Sie die Strategie nur bei schwankenden Marktbedingungen und beobachten Sie die Trendmärkte, um das Risiko eines Rückschlags in den Trendmärkten effektiv zu vermeiden.

  2. Optimieren Sie die Parametersuche. Verwenden Sie intelligente Algorithmen zur Optimierung von Gitterparametern, z. B. genetische Algorithmen, Partikelschwarm-Algorithmen usw., um automatisch die optimale Parameterkombination zu finden und die Optimierungseffizienz und -qualität zu verbessern.

  3. Verbessern Sie die Risikokontrolllogik. Fügen Sie der Strategie mehr Risikokontrolllogik hinzu, z. B. die dynamische Anpassung der Netzbreite an die Preisvolatilität, die Festlegung der maximalen Retracement-Schwelle, um das Schließen auszulösen, usw., um Risiken besser zu kontrollieren.

  4. Eintritt der Trend-Stop-Loss. Setzen Sie eine Trend-Breakthrough-Stop-Loss-Linie, z. B. einen bestimmten Prozentsatz der Gittergrenze. Sobald der Preis durch die Stop-Loss-Linie bricht, schließen Sie alle Positionen, um große Rückschritte in den Trendmärkten zu vermeiden.

  5. Optimierung der Transaktionsdurchführung Optimierung der Transaktionsdurchführungsverbindung, z. B. durch Einführung fortschrittlicherer Auftragsarten und Auftragsalgorithmen, Minimierung der Transaktionsfrequenz und -kosten und Verbesserung der Ausführungseffizienz.

Durch die oben genannte Optimierung können die Anpassungsfähigkeit, Robustheit und Rentabilität dieser Strategie umfassend verbessert werden und sie den tatsächlichen Handelsbedürfnissen näher bringen.

Zusammenfassung

Im Allgemeinen ist diese dynamische Netz-Trend-Folge-Strategie eine mittlere bis hohe Frequenz-quantitative Handelsstrategie, die auf dem Prinzip des Netzhandels basiert und dynamische Anpassungs- und Trendanpassungsmechanismen integriert. Ihre Vorteile liegen in der starken Anpassungsfähigkeit, hohem Automatisierungsgrad, kontrollierbarem Risiko, guter Trendanpassungsfähigkeit und stabiler Gewinnrate. Gleichzeitig hat sie auch Risiken wie Trendrisiko, Schwierigkeiten bei der Optimierung von Parametern, häufigen Handel und starke Abhängigkeit von Marktbedingungen. Angesichts dieser Probleme können Verbesserungen von Trendfilterung, Parameteroptimierung, Risikoerhöhung, Trendstop-Loss-Kontrolle, Transaktionsoptimierung und anderen Aspekten zur Verbesserung der Gesamtleistung der Strategie vorgenommen werden.

Die Idee des Grid-Tradings selbst ist eine relativ reife und praktische quantitative Methode. Durch die Hinzufügung dynamischer Optimierungs- und Trend-Anpassungsmechanismen zu dieser Strategie wurden die Vorteile des klassischen Grid-Tradings erweitert und entwickelt.


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

//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)







Mehr