Basierend auf einer adaptiven dynamischen Long-Short-Grid-Strategie
ChaoZhang
Überblick
Die Kernidee der Strategie ist es, die oberen und unteren Grenzen eines Grids automatisch anhand der höchsten und niedrigsten Punkte oder einfachen gleitenden Durchschnitte der letzten Preise zu berechnen und diese dann in mehrere Grid-Linien zu unterteilen. Wenn der Preis eine bestimmte Grid-Line berührt, wird an dieser Stelle eine Über- oder Niedrigstellung gemacht.
Strategieprinzip
Die ober-und untere Grenze des Rasters wird berechnet. Je nach Benutzerwunsch kann die ober-und untere Grenze basierend auf den höchsten und niedrigsten Punkten der jüngsten N-K-Linie berechnet werden, wobei der Prozentsatz vergrößert oder verkleinert werden kann. Es kann auch basierend auf dem einfachen beweglichen Durchschnitt der jüngsten N-K-Linie berechnet werden, wobei die ober-und untere Abweichung berechnet wird.
Geben Sie die Anzahl der gesetzten Gitterlinien an, um die Anzahl der gesetzten Gitterlinien zu berechnen.
Eintritt/Hauflage. Von unten nach oben durch die Gitterlinie gehen. Wenn der aktuelle Schlusskurs unter dem Preis einer bestimmten Gitterlinie liegt und diese Gitterlinie noch keine Position hält, wird an dieser Stelle eine Position eröffnet. So wird die Position fortgesetzt, wenn der Preis die höhere Gitterlinie berührt.
Ausstieg/Abnahme. Durchlaufen Sie die Gitterlinie von oben nach unten. Wenn der aktuelle Schlusskurs größer ist als der Preis einer Gitterlinie und die unteren Gitterlinien eine Position haben, werden die Multiple der unteren Gitterlinie ausgeglichen.
Dynamische Anpassung: Bei der Auswahl der Dynamischen Gitterfunktion werden die oberen und unteren Grenzen des Gitter und die Arrays der Gitterlinien für jede K-Leitung neu berechnet, so dass das Gitter sich ständig an die Veränderungen anpassen kann.
Analyse der Stärken
Anpassungsfähig. Die Grid-Handelsstrategie ist in der Lage, sich auf Erschütterungen und Trends einzustellen. In Erschütterungen kann die Grid-Strategie dauerhaft Positionen platzieren und Preisunterschiede einnehmen. In Trends kann die Grid aufgrund der Preisbewegung auch bestimmte Positionen halten und Trendgewinne erzielen.
Risikokontrolle. Die Größe der Positionen, die bei jeder Position eröffnet werden, wird durch die Anzahl der gesetzten Grids bestimmt. Die Einzelschnittrisikoöffnung ist klein und kontrollierbar.
Die Strategie funktioniert im Wesentlichen vollständig automatisch, ohne menschliche Intervention, und ist für Investoren geeignet, die langfristige, stabile Erträge benötigen.
Der Benutzer kann die Anzahl der Gitterlinien, die dynamischen Gitterparameter usw. flexibel anhand von Marktmerkmalen einstellen, um die Strategie zu optimieren.
Risikoanalyse
Black Swan-Risiko: Bei einem extremen Kurssturz, bei dem der Preis direkt unter die niedrigste Gridlinie springt, ist die Strategie voll und droht einem größeren Rückzug. Um dieses Risiko zu verringern, können Sie eine Stop-Loss-Bedingung einrichten, die die gesamte Position freigibt, sobald die Verluste den Wert erreicht haben.
Die Grid-Parameter sind nicht korrekt eingestellt. Wenn das Grid zu dicht ist, ist der Preisdifferenz für jede offene Position sehr gering, und die Gebühren können den größten Teil der Gewinne auslöschen. Wenn das Grid zu breit ist, ist der Anteil der Einmal-Positionen hoch und die Risikolocke groß.
Basisdifferenzrisiko. Die Strategie basiert auf den Bedingungen für die Eröffnung einer Position zum aktuellen Preis. In Märkten wie Futures kann der tatsächliche Preis für die Eröffnung einer Position von der erwarteten Abweichung abweichen, wenn der Vertragspreis stark von dem angegebenen Preis abweicht.
Optimierungsrichtung
Trend-Filter hinzufügen. Die Grid-Strategie funktioniert schlecht bei einseitigen Trends. Sie können Trendindikatoren als Filter hinzufügen, z. B. das Grid nur aktivieren, wenn der ADX unter einem bestimmten Tiefpunkt liegt, und das Grid schließen, wenn der Trend sichtbar ist, und nur einseitige Positionen halten.
Optimierung der Signale: Sie können andere Signale auf der Basis des Rasters überlagern, z. B. Raster + Durchschnittslinie, d. h. es wird hauptsächlich von der Raster entschieden, eine Position zu eröffnen, aber wenn der Preis eine bestimmte Durchschnittslinie überschreitet, wird die Position eröffnet, sonst wird sie nicht eröffnet. So können die Kosten für die häufige Eröffnung von Positionen gesenkt werden.
Positionsmanagement. Derzeit ist die Strategie mit einer festen Position pro Stück konzipiert. Sie kann so eingestellt werden, dass die Position pro Stück bei einem Preis, der weit vom Marktdurchschnitt entfernt ist, entsprechend gesenkt wird.
Anpassung der Gitterdichte. Die Gitterdichte wird dynamisch an die Preisschwankungen angepasst. Bei hoher Schwankung kann die Anzahl der Gitter entsprechend erhöht und bei niedrigerer Schwankung reduziert werden.
Zusammenfassen
Die Strategie ist eine sehr anpassungsfähige mittelfristige lineare Quantifizierungsstrategie, die sich an ein dynamisches Netz anpasst, die in der Lage ist, bei Erschütterungen häufig Positionen zu platzieren, aber auch eine bestimmte Ausgangsrichtung bei Trendbewegungen zu halten. Durch eine vernünftige Einstellung der Grid-Triggerlogik und Positionsverwaltung können stabile Gewinne erzielt werden.
// 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)