Estratégia de negociação quantitativa de tendência de rede dinâmica

Autora:ChaoZhang, Data: 2024-03-22 16:03:09
Tags:

img

Resumo

Esta é uma estratégia de negociação quantitativa avançada de tendência de rede dinâmica. A ideia principal desta estratégia é dividir várias linhas de rede dentro de uma faixa de preços pré-estabelecida e abrir posições automaticamente quando o preço atinge as linhas de rede e fechar posições ao vender, lucrando assim com os mercados flutuantes. Ao mesmo tempo, esta estratégia também tem a função de ajustar dinamicamente a posição das linhas de rede, o que pode otimizar adaptativamente o layout da rede de acordo com as tendências de preços recentes.

Princípio da estratégia

Os princípios fundamentais desta estratégia são os seguintes:

  1. Primeiro, determine os limites superior e inferior da grade e o número de linhas da grade com base nas configurações do usuário.

  2. Dentro dos limites determinados, divida a faixa de preços em várias grades. Cada linha da grade corresponde a um preço de compra ou venda.

  3. Quando o preço atinge cada linha da grade, a estratégia verificará se a posição correspondente à linha da grade já está realizada.

  4. Ao vender em posições relativamente altas e comprar em posições baixas, a estratégia pode lucrar continuamente quando os preços flutuam.

  5. Ao mesmo tempo, se o utilizador ativar a função de ajuste automático dos limites, a posição das linhas da grade será ajustada de forma adaptativa de acordo com os recentes máximos e mínimos de preços ou a média móvel definida para otimizar o traçado da grade.

Através dos princípios acima, esta estratégia pode realizar automaticamente compras baixas e vendas altas em tendências de preços flutuantes, e ajustar os pontos de lucro de acordo com as tendências, melhorando assim os retornos globais.

Análise das vantagens

Esta estratégia de rede dinâmica tem as seguintes vantagens:

  1. Forte adaptabilidade: pode adaptar-se a diferentes mercados e variedades através de definições de parâmetros e tem uma boa adaptabilidade aos mercados flutuantes.

  2. Uma vez que a estratégia é baseada em lógica matemática rigorosa e pontos claros de abertura e fechamento de posição, pode alcançar negociação totalmente automatizada e reduzir a interferência emocional subjetiva.

  3. Risco controlado: através da fixação de parâmetros como o número de redes e os limites da rede, a exposição ao risco de cada transacção pode ser eficazmente controlada, mantendo assim o risco global dentro de um intervalo aceitável.

  4. Adaptabilidade à tendência: A função de ajuste dinâmico dos limites da rede é adicionada à estratégia, de modo que a rede possa seguir as tendências de preços e ser otimizada, melhorando a rentabilidade nos mercados de tendência.

  5. Taxa de ganho estável. Uma vez que a negociação de rede é essencialmente frequente, lançando alto e sugando baixo nas flutuações de preços, desde que o preço mantenha flutuações, essa estratégia pode continuar a lucrar, por isso tem uma alta taxa de ganho a longo prazo.

Análise de riscos

Apesar de esta estratégia ter vantagens óbvias, comporta também certos riscos:

  1. Risco de tendência: se o preço atravessar o limite da rede com uma forte tendência unilateral, o espaço de lucro desta estratégia será limitado e pode enfrentar uma grande retração.

  2. Dificuldade na otimização de parâmetros. Esta estratégia tem muitos parâmetros, incluindo o número de grades, limites iniciais, parâmetros de limites dinâmicos, etc. Diferentes combinações de parâmetros têm um grande impacto no desempenho da estratégia, e a dificuldade de otimização real não é pequena.

  3. A estratégia de rede é essencialmente uma estratégia de alta frequência, com abertura e fechamento muito frequentes de posições, o que significa custos de transação mais elevados e riscos potenciais de deslizamento.

  4. Dependência forte das condições do mercado. Esta estratégia é altamente dependente de mercados flutuantes. Uma vez que o preço entra em uma tendência unilateral rápida, esta estratégia provavelmente enfrentará uma grande retração.

Tendo em conta estes riscos, podem ser realizadas melhorias a partir dos seguintes aspectos: adição de indicadores de julgamento de tendência como condições de filtro para o início da estratégia, otimização do espaço e métodos de pesquisa de parâmetros, introdução de gestão de fundos e lógica de controlo de posição, aumento da lógica de fechamento de tendência, etc. Através destas otimizações, a robustez e rentabilidade desta estratégia podem ser ainda melhoradas.

Direcção de otimização

Com base na análise anterior, as direcções de otimização desta estratégia incluem principalmente:

  1. Introduza condições de filtragem de tendências. Adicione indicadores de julgamento de tendências antes do início da estratégia, como médias móveis, ADX, etc. Apenas inicie a estratégia em condições de mercado flutuantes e mantenha-se atento nos mercados de tendências para evitar efetivamente o risco de retração nos mercados de tendências.

  2. Optimize a pesquisa de parâmetros. Use algoritmos inteligentes para otimizar parâmetros de grade, como algoritmos genéticos, algoritmos de enxame de partículas, etc., para encontrar automaticamente a combinação de parâmetros ideal e melhorar a eficiência e qualidade da otimização.

  3. Melhorar a lógica de controle de risco. Adicionar mais lógica de controle de risco à estratégia, como ajustar dinamicamente a largura da rede de acordo com a volatilidade dos preços, definir o limite máximo de retração para desencadear o fechamento, etc., para melhor controlar os riscos.

  4. Introduzir uma linha de stop loss de tendência. Definir uma linha de stop loss de transição de tendência, como uma certa porcentagem do limite da grade. Uma vez que o preço atravessa a linha de stop loss, feche todas as posições para evitar grandes retrações nos mercados de tendência.

  5. Otimizar a execução das transações, como a adoção de tipos de ordens e algoritmos de ordens mais avançados, minimizando a frequência e os custos das transações e melhorando a eficiência da execução.

Através da otimização acima referida, a adaptabilidade, a robustez e a rentabilidade desta estratégia podem ser ampliamente melhoradas, aproximando-a das necessidades reais de negociação.

Resumo

Em geral, esta estratégia de seguimento de tendências de rede dinâmica é uma estratégia de negociação quantitativa de média a alta frequência baseada no princípio da negociação de rede, e integra mecanismos de ajuste dinâmico e adaptação de tendências. Suas vantagens estão em forte adaptabilidade, alto grau de automação, risco controlado, boa adaptabilidade de tendências e taxa de vitória estável. Ao mesmo tempo, também tem riscos como risco de tendência, dificuldade na otimização de parâmetros, negociação frequente e forte dependência das condições do mercado. Tendo em vista esses problemas, podem ser feitas melhorias a partir da filtragem de tendências, otimização de parâmetros, aprimoramento de riscos, controle de tendência stop loss, otimização de transações e outros aspectos para melhorar o desempenho geral da estratégia.

A ideia de negociação em rede em si é um método quantitativo relativamente maduro e prático. Através da adição de mecanismos de otimização dinâmica e adaptação de tendências a esta estratégia, as vantagens da negociação em rede clássica foram estendidas e desenvolvidas. Ele fornece aos investidores uma nova ideia de negociação quantitativa e possibilidade em mercados flutuantes. Com otimização e melhoria adicionais, espera-se que esta estratégia se torne uma excelente ferramenta de negociação quantitativa de média a alta frequência.


/*backtest
start: 2024-03-01 00:00:00
end: 2024-03-21 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)







Mais.