Die Ressourcen sind geladen. Beförderung...

Eine lang-kurzfristige anpassungsfähige dynamische Netzstrategie auf der Grundlage

Schriftsteller:ChaoZhang, Datum: 2024-03-19 14:19:12
Tags:

img

Übersicht

Dies ist eine lang-kurze adaptive dynamische Gitterhandelsstrategie, die auf Pine Script basiert. Die Kernidee dieser Strategie besteht darin, die oberen und unteren Grenzen eines Gittersystems automatisch auf der Grundlage der jüngsten Preishochs und -tiefs oder eines einfachen gleitenden Durchschnitts zu berechnen und diesen Bereich dann gleichmäßig in mehrere Gitterlinien zu teilen. Wenn der Preis eine bestimmte Gitterlinie erreicht, wird er eine lange Position öffnen oder eine Position auf diesem Niveau schließen. Auf diese Weise kann die Strategie kontinuierlich Positionen in einem Bereichsmarkt öffnen und schließen, um den Preisverlauf zu erfassen. Gleichzeitig kann sie sich durch dynamische Anpassung der Gittergrenzen auch an verschiedene Markttrends anpassen.

Strategieprinzipien

  1. Berechnen Sie die Gittergrenzen. Basierend auf der Wahl des Benutzers können die Grenzen von den höchsten und tiefsten Punkten der jüngsten N-Kerzen berechnet werden, wobei die Option besteht, den Bereich um einen Prozentsatz zu erweitern oder zu verengen; oder sie können auf der Grundlage des einfachen gleitenden Durchschnitts der Schlusskuren der jüngsten N-Kerzen basieren, wobei die Option besteht, die Abweichungsquoten nach oben und unten festzulegen.

  2. Entsprechend der festgelegten Anzahl von Netzlinien teilen Sie den Netzbereich gleichmäßig, um ein Array von Netzliniepreisen zu erzeugen.

  3. Eintritt/Zusatzposition. Durchqueren Sie die Gitterlinien von unten nach oben. Wenn der aktuelle Schlusskurs kleiner als ein Gitterliniepreis ist und es keine Position auf dieser Gitterlinie gibt, öffnen Sie dann eine Longposition auf dieser Ebene. Auf diese Weise wird der Preis, wenn er höhere Gitterlinien erreicht, weiterhin Positionen hinzufügen.

  4. Ausgang / Verringerung der Position. Durchqueren Sie die Gitterlinien von oben nach unten. Wenn der aktuelle Schlusskurs größer ist als ein Gitterliniepreis und es eine Position auf der Gitterlinie unten gibt, schließen Sie dann die Long-Position auf der unteren Gitterlinie. Auf diese Weise, wenn der Preis zurückfällt, wird er weiterhin Positionen reduzieren.

  5. Dynamische Anpassung: Wenn die dynamische Gitterfunktion ausgewählt wird, werden die oberen und unteren Grenzen des Gittersystems und das Gitterlinie-Array auf jeder Kerze neu berechnet, so dass sich das Gittersystem ständig an die Veränderungen des Marktes anpassen kann.

Analyse der Vorteile

  1. Starke Anpassungsfähigkeit. Die Grid-Handelsstrategie kann sich sowohl an die Rangebound- als auch an die Trending-Märkte anpassen. In einem Rangebound-Markt kann die Grid-Strategie kontinuierlich Positionen öffnen und schließen, um den Preisspread zu erzielen; in einem Trending-Markt kann sie, da das Grid der Preisbewegung folgt, auch eine bestimmte Position beibehalten, um Trendgewinne zu erzielen.

  2. Das Risiko ist überschaubar. Die Positionsgröße jeder Öffnung wird durch die festgelegte Anzahl von Gitter bestimmt, so dass die einzelne Risikoposition klein und überschaubar ist. Da die oberen Gitterlinien erreicht werden, werden Positionen für Gewinn geschlossen, es sichert auch potenzielle Verluste bis zu einem gewissen Grad.

  3. Diese Strategie kann grundsätzlich ohne manuelle Eingriffe vollautomatisch ausgeführt werden, was für Anleger geeignet ist, die langfristige, stabile Renditen benötigen.

  4. Flexible Parameter: Benutzer können die Anzahl der Netzlinien, dynamische Netzparameter usw. flexibel nach den Merkmalen des Marktes festlegen, um die Strategieleistung zu optimieren.

Risikoanalyse

  1. Bei einem extremen Marktcrash, wenn der Preis direkt unter die niedrigste Gitterlinie fällt, wird die Strategie vollständig positioniert und einem größeren Drawdown ausgesetzt sein. Um dieses Risiko zu reduzieren, kann eine Stop-Loss-Bedingung festgelegt werden, um alle Positionen zu schließen, sobald der Verlust einen Schwellenwert erreicht.

  2. Fehlende Einstellung der Netzparameter. Wenn die Netzdichte zu hoch ist, ist die Ausbreitung der beiden Öffnungs- und Schließungen sehr gering, und die Transaktionskosten können die meisten Gewinne erodieren. Wenn die Netzbreite zu groß ist, ist die Einmalöffnungsquote hoch und die Risikoposition groß. Die Eigenschaften des zugrunde liegenden Vermögenswerts müssen sorgfältig ausgewertet werden, um geeignete Netzparameter auszuwählen.

  3. Basisrisiko: Diese Strategie legt die Eröffnungs- und Schlusskonditionen anhand des aktuellen Preises fest. Auf Märkten wie Futures können sich die tatsächlichen Eröffnungs- und Schlusskosten erheblich von den Erwartungen abweichen, wenn sich der Vertragspreis stark vom Basispreis unterscheidet.

Optimierungsrichtlinien

  1. Hinzufügen eines Trendfilters. Grid-Strategien funktionieren nicht gut in einseitigen Trending-Märkten. Trendindikatoren können als Filter hinzugefügt werden, z. B. nur dann das Grid aktivieren, wenn ADX unter einem Schwellenwert liegt, und das Grid schließen, wenn der Trend offensichtlich ist, nur einseitige Positionen halten.

  2. Signaloptimierung. Andere Signale können auf der Grundlage des Gitterplatzes überlagert werden, wie z. B. Gitter + gleitender Durchschnitt, dh das Öffnen und Schließen werden hauptsächlich durch das Gitter bestimmt, aber nur geöffnete Positionen, wenn der Preis einen bestimmten gleitenden Durchschnitt überschreitet, andernfalls nicht geöffnete Positionen. Dies kann die Kosten für häufiges Öffnen und Schließen reduzieren.

  3. Derzeit ist die Position jedes Netzes in der Strategie festgelegt. Es kann so eingestellt werden, dass die Position jedes Netzes angemessen reduziert wird, wenn der Preis weit vom Marktdurchschnitt ist, und die Position erhöht wird, wenn sie nahe dem Marktdurchschnitt ist, um die Effizienz der Kapitalnutzung zu verbessern.

  4. Adaptive Netzdichte. Dynamisch die Netzdichte entsprechend der Preisvolatilität anpassen. Wenn die Volatilität hoch ist, kann die Anzahl der Netze angemessen erhöht werden; wenn die Volatilität niedrig ist, kann die Anzahl der Netze reduziert werden. Dies kann die Netzbreite optimieren und die Kapitalnutzung verbessern.

Zusammenfassung

Durch adaptive dynamische Gitter kann diese Strategie häufig Positionen öffnen und schließen, um Preisspannen in den Rangebound-Märkten zu erzielen, und kann auch eine gewisse Expositionsrichtung in den Trendmärkten beibehalten, um Trendgewinne zu erzielen. Es ist eine mittelfristige bis langfristige quantitative Strategie mit starker Anpassungsfähigkeit. Durch eine angemessene Einstellung des Grids, die Logik und das Positionsmanagement auslöst, können stetige Renditen erzielt werden. Es ist jedoch notwendig, auf die Risiken extremer Marktbedingungen und Preislücken zu achten, die die Festlegung geeigneter Stop-Loss-Bedingungen zur Kontrolle erfordern. Darüber hinaus gibt es weitere Optimierungsmöglichkeiten bei Parameter-Einstellung und Risikomanagement. Die Robustheit und Rentabilität der Strategie kann durch die Einführung von Trendfilterung, Signalüberlagerung, Positionsmanagement, adaptive Gitterdichte und andere Mittel verbessert werden. Zusammenfassend basierend auf der Grundlogik von Gittern


// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © jcloyd

//@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