A estratégia de cobertura de risco de negociação em rede é uma estratégia de negociação quantitativa baseada no conceito de negociação em rede, combinada com a ideia de cobertura de risco. A estratégia define várias ordens de compra e venda dentro de uma faixa de preços predefinida para lucrar com as flutuações de preços. Ao mesmo tempo, a estratégia introduz um mecanismo de cobertura de risco que ajusta dinamicamente os limites da rede para se adaptar às mudanças no ambiente do mercado e reduzir os riscos da estratégia.
O princípio central desta estratégia é a negociação em rede. Primeiro, com base nos parâmetros definidos pelo usuário, os limites superior e inferior da rede e o número de linhas de rede são determinados. Em seguida, as ordens de compra e venda são colocadas nas linhas de rede: quando o preço toca uma linha de rede, se não houve ordem nessa linha de rede antes, uma posição é aberta; se houve uma ordem antes, a posição é fechada. Desta forma, a estratégia pode abrir e fechar continuamente posições em flutuações de preços para obter lucros.
Ao mesmo tempo, para reduzir os riscos, a estratégia introduz um mecanismo de ajuste dinâmico dos limites da rede. De acordo com a escolha do usuário, os limites superior e inferior da rede podem ser ajustados automaticamente de duas maneiras: 1) com base nos preços mais altos e mais baixos no período recente, considerando o desvio definido pelo usuário; 2) com base na linha média móvel, considerando o desvio definido pelo usuário. Ao ajustar dinamicamente os limites da rede, a rede sempre pode ser centrada em torno do preço atual, reduzindo assim o risco de o preço quebrar os limites da rede.
Além disso, ao abrir uma posição, a estratégia divide os fundos totais em N partes iguais e, cada vez que abre uma posição, utiliza uma quantidade igual de fundos, o que pode reduzir o risco de uma única transação.
Forte adaptabilidade: ao ajustar dinamicamente os limites da rede, a estratégia pode adaptar-se a diferentes ambientes de mercado.
Risco controlado: a estratégia utiliza quantidades iguais de fundos ao abrir posições, pelo que o risco de uma única transação é pequeno; ao mesmo tempo, o mecanismo dinâmico de ajustamento dos limites da rede pode reduzir o risco de os preços ultrapassarem os limites da rede.
Alta frequência de negociação: uma vez que a rede geralmente tem muitas ordens, a frequência de negociação é alta, facilitando o lucro em mercados voláteis.
Parâmetros flexíveis: os utilizadores podem definir o número de grades, limites superiores e inferiores, parâmetros de ajuste dinâmico, etc., de acordo com as suas preferências, adaptando-se assim aos diferentes estilos de negociação.
Mal desempenho nos mercados de tendência: se o preço continuar a subir ou a cair unilateralmente, ultrapassando os limites da rede, e o ajustamento dinâmico não conseguir acompanhar a velocidade das alterações de preços, a estratégia pode enfrentar riscos maiores.
As taxas de transacção: uma vez que a estratégia tem uma elevada frequência de negociação, as taxas de transacção podem ter um certo impacto nos retornos.
Configuração de parâmetros inadequada: se os parâmetros forem definidos de forma inadequada, tais como demasiadas linhas de rede ou configurações irracionais dos limites da rede, pode levar a um mau desempenho da estratégia.
Soluções: 1) Em mercados de tendência, considere aumentar o intervalo de ajuste dos limites da rede ou combiná-lo com estratégias de tendência; 2) Escolha bolsas e moedas com taxas de transação mais baixas; 3) Antes da operação real, os parâmetros precisam ser totalmente testados e otimizados.
Combinar com outras estratégias: considerar a combinação de estratégias de negociação de rede com outros tipos de estratégias, como estratégias de tendência, estratégias de reversão média, etc., para melhorar a adaptabilidade e a estabilidade da estratégia.
Melhorar o mecanismo de ajustamento dinâmico: o mecanismo de ajustamento dinâmico atual na estratégia é relativamente simples e pode ser otimizado ainda mais, por exemplo, considerando mais fatores (como volume de negociação, volatilidade, etc.) e adotando algoritmos mais avançados (como algoritmos adaptativos, algoritmos de aprendizado de máquina, etc.).
Otimizar a gestão de fundos: atualmente, a estratégia adota uma gestão de fundos igualitária. Podemos considerar a introdução de métodos de gestão de fundos mais avançados, como o Critério Kelly, métodos de otimização, etc., para melhorar ainda mais a eficiência e os retornos da utilização de fundos.
Introduzir lucro e stop loss: com base na negociação em rede, pode ser introduzida uma lógica de lucro e stop loss, como mover lucro e stop loss, volatilidade, lucro e stop loss, etc., para reduzir ainda mais os riscos da estratégia.
A estratégia de cobertura de risco de negociação em rede é uma estratégia quantitativa de negociação altamente automatizada, adaptável e controlada pelo risco. Através da negociação em rede e do ajuste dinâmico da rede, a estratégia pode lucrar em várias condições de mercado, controlando os riscos. No entanto, a estratégia pode ter um desempenho ruim nos mercados de tendência e as taxas de transação podem afetar os retornos. Portanto, é necessária uma otimização e melhoria adicionais em aplicações práticas.
/*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)