Estratégia de hedge de risco de negociação de grade
ChaoZhang
Visão geral da estratégia
A estratégia de hedge de risco de negociação de grades é uma estratégia de negociação quantitativa baseada na ideia de negociação de grades, combinada com a ideia de hedge de risco. A estratégia de hedge de risco é introduzida, além disso, para reduzir o risco da estratégia, ajustando dinamicamente os limites da grades para se adaptar às mudanças do ambiente de mercado.
Princípio da estratégia
O princípio central da estratégia é a negociação de grades. Primeiro, determine o limite superior e inferior da grade e o número de linhas de grade de acordo com os parâmetros definidos pelo usuário. Em seguida, coloque uma ordem de compra e venda na linha de grade: se não houver uma ordem antes da linha de grade, abra uma posição quando o preço toca a linha de grade; se houver uma ordem antes, feche a posição.
Ao mesmo tempo, para reduzir o risco, a estratégia também introduziu um mecanismo de ajuste dinâmico dos limites da grade. De acordo com a escolha do usuário, os limites superiores e inferiores da grade podem ser ajustados automaticamente de duas maneiras: 1) De acordo com os preços mais altos e mais baixos do período mais recente, e considerando o deslocamento definido pelo usuário; 2) De acordo com a média móvel, e considerando o deslocamento definido pelo usuário.
Além disso, a estratégia divide o capital total em N partes, e usa a mesma quantidade de capital em cada posição, reduzindo o risco de uma única transação.
Análise de vantagens
Adaptabilidade: A estratégia pode se adaptar a diferentes ambientes de mercado, seja em tendências ou turbulências, ajustando-se automaticamente para obter melhores resultados.
Risco controlado: a estratégia usa a mesma quantidade de capital na abertura da posição, com menor risco de transação única; ao mesmo tempo, o mecanismo de ajuste da borda da grade dinâmica pode reduzir o risco de quebrar a borda da grade.
Alta frequência de negociação: Como a grelha geralmente coloca mais pedidos, a frequência de negociação é mais alta e é mais fácil lucrar em situações de volatilidade.
Flexibilidade de parâmetros: os usuários podem se adaptar a diferentes estilos de negociação de acordo com suas preferências, configurando o número de grades, limites superiores e inferiores, parâmetros de ajuste dinâmico, etc.
Análise de Riscos
Desempenho fraco em um cenário de tendência: a estratégia pode estar em maior risco se os preços continuarem subindo ou descendo de forma unilateral, ultrapassando os limites da grelha, e se o ajuste dinâmico não acompanhar a velocidade com que os preços mudam.
As taxas de comissões podem afetar os lucros devido à alta frequência de negociação da estratégia.
Configuração de parâmetros incorreta: Se os parâmetros são configurados de forma incorreta, como o número excessivo de grades, a configuração de fronteiras de grades imprópria, etc., pode causar um mau desempenho da política.
Soluções: 1) Em situações de tendência, pode-se considerar a amplitude de ajuste dos limites da grelha maior, ou em combinação com a estratégia de tendência; 2) Escolha de exchanges e moedas com taxas mais baixas; 3) Antes da operação real, os parâmetros precisam ser bem avaliados e otimizados.
Direção de otimização
Combinação com outras estratégias: pode-se considerar a combinação da estratégia de negociação da grelha com outros tipos de estratégias, como estratégias de tendência, estratégias de regressão ao valor médio, etc., para aumentar a adaptabilidade e a estabilidade da estratégia.
Melhorar o mecanismo de ajuste dinâmico: O mecanismo de ajuste dinâmico na estratégia atual é relativamente simples e pode ser otimizado ainda mais, como considerar mais fatores (como volume de tráfego, taxa de flutuação, etc.), adotando algoritmos mais avançados (como algoritmos de auto-adaptação, algoritmos de aprendizado de máquina, etc.).
Gerenciamento de fundos de otimização: A estratégia atual utiliza o gerenciamento de fundos equivalentes, e pode considerar a introdução de métodos de gestão de fundos mais avançados, como a Lei de Kelly, métodos de otimização, etc., para melhorar ainda mais a eficiência e a rentabilidade do uso de fundos.
Introdução de Stop Losses: Com base na negociação da grelha, é possível introduzir algumas lógicas de Stop Losses, como Stop Losses móveis e Stop Losses de taxa de flutuação, para reduzir ainda mais o risco da estratégia.
Resumir
A estratégia de hedging de risco de negociação de grades é uma estratégia de negociação quantitativa altamente automatizada, adaptável e com risco controlado. Com a negociação de grades e o ajuste de grades dinâmicos, a estratégia pode lucrar em vários cenários e, ao mesmo tempo, controlar o risco.
/*backtest
start: 2024-03-19 00:00:00
end: 2024-03-23 00:00:00
period: 5m
basePeriod: 1m
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)