Estratégia de negociação de grade quantitativa adaptativa ativa
ChaoZhang
Visão geral
Esta estratégia estabelece uma grelha de negociação de ajuste dinâmico para obter lucros estáveis em situações de volatilidade. A estratégia calcula automaticamente o intervalo de grelha e o preço superior e inferior de acordo com o número de grelhas definido. Quando o preço atravessa cada linha de grelha, a posição é aumentada ou esvaziada em lotes.
Princípio da estratégia
Arquivos de preços de linhas de grelha e limites de grelha com base em parâmetros de entrada.
Quando o preço está abaixo de uma certa linha de grade e não há correspondente pendurar a linha de grade, em que o ponto de preço da linha de grade de criação de mais de uma ordem; quando o preço é superior ao da linha de grade anterior (exceto o primeiro) e a linha de grade anterior existe correspondente a posse da ordem, nivelar a linha de grade de uma linha de grade de fazer mais de uma ordem correspondente.
Se o parâmetro de grade de ajuste automático for ativado, o preço máximo e mínimo da grade, o intervalo da grade e a matriz da grade serão recalculados periodicamente com base no número de dados de linhas K mais recentes.
Análise de vantagens
A meta de lucro em situações de volatilidade é alcançada. Em situações de queda e queda, a capacidade de estabelecer posições de detenção e de parada em diferentes pontos de preço em lotes, permitindo a obtenção de lucro em geral.
Pode-se escolher ajustar os parâmetros da grade manualmente ou automaticamente. O ajuste manual requer intervenção humana, mas é mais controlado; o ajuste automático reduz a quantidade de trabalho operacional e permite que a estratégia se adapte às mudanças no ambiente de mercado.
Ao limitar o número máximo de grades, é possível controlar o risco unilateral. O risco nesta direção é controlado quando o preço atravessa todas as linhas da grelha.
Pode-se ajustar o intervalo da grade para controlar a perda de cada lote. Reduzir o intervalo da grade pode reduzir a perda de cada lote.
Análise de Riscos
Em situações de grande volatilidade, existe o risco de ser arbitragem. Se o preço oscila rapidamente entre várias grades, pode haver risco de arbitragem.
É necessário estabelecer uma quantidade razoável de capital inicial. Se o capital inicial não for suficiente, não será possível suportar o número suficiente de linhas de rede.
O número excessivo de grades ou o número excessivo de grades é prejudicial para o lucro da estratégia. O número excessivo de grades não permite aproveitar ao máximo a volatilidade; o excesso de grades é pequeno para o lucro individual.
Há um risco de manipulação dos parâmetros da grade de ajuste automático. O cálculo dos parâmetros da grade depende de um certo número de linhas K, que pode ser afetado por operações de curto prazo.
Direção de otimização
Aumentar a lógica de stop-loss, como a configuração de stop-loss flutuante ou stop-loss de rastreamento, para controlar ainda mais o risco de perda unilateral.
Adicionar um algoritmo para otimizar os parâmetros da grade. Pode testar configurações de parâmetros em diferentes fases do mercado e, em seguida, treinar modelos com métodos de aprendizado de máquina para otimizar automaticamente os parâmetros.
Combine mais indicadores para julgar a situação. Julgar se o MACD, o KD e outros estão em uma tendência ascendente ou descendente para ajustar o número de grades ou os parâmetros.
Otimizar o controle de retração. Por exemplo, definir a taxa de retração máxima e fechar a estratégia quando atingir o limiar, para evitar que os prejuízos se ampliem ainda mais.
Resumir
Esta estratégia aproveita ao máximo as características da volatilidade, com o objetivo de obter um lucro estável através de negociação de grelha dinâmica. A estratégia considera a flexibilidade do ajuste de parâmetros e reduz a intensidade de trabalho da operação. Pode-se dizer que, em situações de volatilidade, a estratégia é uma opção de lucro ideal.
/*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)