Aktive adaptive quantitative Grid-Trading-Strategie
ChaoZhang
Überblick
Die Strategie berechnet automatisch die Grid-Intervalle und die Obergrenze der Preise auf der Grundlage der festgelegten Anzahl von Gitter. Wenn der Preis jede Gitterlinie durchbricht, werden die Positionen in Schuhen überbucht oder gelöscht. Wenn der Preis die ursprüngliche Gitterlinie wieder berührt, werden die Positionen schrittweise abgebremst.
Strategieprinzip
Grid-Grenzen und Grid-Line-Preis-Arrays berechnet anhand der Eingabeparameter.
Wenn der Preis unter einer bestimmten Gitterlinie liegt und diese keine entsprechenden Aufträge hat, wird ein Mehrausweis an diesem Preispunkt erstellt. Wenn der Preis höher ist als die vorherige Gitterlinie (ausgenommen die erste) und eine entsprechende Haltestelle auf der vorherigen Gitterlinie vorhanden ist, wird der entsprechende Mehrausweis auf der vorherigen Gitterlinie ausgeglichen.
Wenn die automatische Anpassung der Grid-Parameter aktiviert ist, werden die oberen und unteren Grenzwerte, die Grid-Abstände und die Grid-Arrays regelmäßig neu berechnet, basierend auf der letzten Anzahl von K-Linien-Daten.
Analyse der Stärken
Erreicht das Ziel, in schwankenden Verhältnissen profitabel zu sein. In beherrschenden Verhältnissen kann die Errichtung von Holdings und Stop-Living-Positionen in verschiedenen Preispunkten erfolgen, um insgesamt profitabel zu sein.
Man kann die Parameter des Rasters manuell oder automatisch anpassen. Die manuelle Anpassung erfordert eine manuelle Intervention, ist jedoch kontrollierbarer. Die automatische Anpassung reduziert den Betriebsaufwand und ermöglicht der Strategie, sich an die Veränderungen der Marktumgebung anzupassen.
Einseitige Risiken können durch die Begrenzung der maximalen Anzahl von Gitterlinien kontrolliert werden. Das Risiko in dieser Richtung wird kontrolliert, wenn der Preis alle Gitterlinien durchbricht.
Durch die Anpassung des Rasterabstands kann die Verlustquote pro Einheit kontrolliert werden. Durch die Verringerung des Rasterabstands kann der Verlust pro Einheit verringert werden.
Risikoanalyse
Bei starker Volatilität besteht die Gefahr, eingeschränkt zu werden. Wenn der Preis zwischen mehreren Gittern schnell hin und her schwankt, besteht die Gefahr, eingeschränkt zu werden.
Es ist notwendig, eine angemessene Anfangsfinanzierung einzurichten. Wenn die Anfangsfinanzierung nicht ausreicht, kann nicht genügend Netzleitungen unterstützt werden.
Eine zu große oder zu kleine Anzahl von Gittern ist für die Strategie unvorteilhaft. Eine zu geringe Anzahl von Gittern kann die Volatilität nicht voll ausnutzen. Eine zu hohe Anzahl von einzelnen Gewinnen ist zu klein.
Es besteht die Gefahr, dass die Parameter des automatischen Anpassungsgitters manipuliert werden. Die Berechnung der Gitterparameter ist abhängig von einer bestimmten Anzahl von K-Linien und kann von kurzfristigen Operationen beeinflusst werden.
Optimierungsrichtung
Erhöhung der Stop-Logik, z. B. durch Einrichtung von Floating-Stops oder Tracking-Stops, um einseitige Verlustrisiken weiter zu kontrollieren.
Zusätzliche Algorithmen optimieren die Grid-Parameter. Die Parameter-Einstellungen für verschiedene Marktphasen können getestet werden, um die Modelle dann mit einer Methode des maschinellen Lernens zu trainieren und die Parameter automatisch zu optimieren.
In Kombination mit mehr Indikatoren beurteilen Sie die Situation. Beurteilen Sie, ob MACD, KD und andere derzeit im Auf- oder Abwärtstrend sind, um die Anzahl oder die Parameter des Rasters anzupassen.
Optimierung der Rückzugskontrolle. So wird z. B. ein maximaler Rückzugssatz festgelegt, der die Strategie beim Erreichen der Schwelle abschaltet, um eine weitere Ausweitung des Verlusts zu vermeiden.
Zusammenfassen
Diese Strategie nutzt die Eigenschaften von Volatilität und erreicht die Ziele eines stabilen Gewinns durch dynamische Grid-Handel. Die Strategie berücksichtigt sowohl die Flexibilität der Parameter-Einstellungen als auch die Arbeitsintensität.
/*backtest
start: 2024-01-02 00:00:00
end: 2024-02-01 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)