Tendência de grade dinâmica seguindo estratégia de negociação quantitativa


Data de criação: 2024-03-22 16:03:09 última modificação: 2024-03-22 16:03:09
cópia: 0 Cliques: 1231
1
focar em
1617
Seguidores

Tendência de grade dinâmica seguindo estratégia de negociação quantitativa

Visão geral

Trata-se de uma estratégia de negociação quantitativa de rastreamento de tendências de grelha dinâmica avançada. A principal idéia da estratégia é dividir várias linhas de grelha dentro de intervalos de preços predefinidos e, quando o preço toca a linha de grelha, criar automaticamente uma compra ou venda de posição baixa, para obter lucro em situações de turbulência. A estratégia também possui a função de ajustar dinamicamente a posição da linha de grelha e pode otimizar o layout da grelha de acordo com a movimentação de preços mais recente.

Princípio da estratégia

Os princípios centrais da estratégia são os seguintes:

  1. O limite pode ser um valor fixo, ou pode ser calculado automaticamente com base em altas e baixas recentes ou médias móveis.

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

  3. A estratégia verifica se uma posição correspondente à linha de grade já foi mantida em cada vez que o preço toca a linha de grade. Se não houver, a posição é comprada e, se houver, a posição é vendida.

  4. A estratégia de vender em preços relativamente altos e comprar em preços baixos permite obter lucros contínuos em situações de volatilidade.

  5. Ao mesmo tempo, se o usuário ativar a função de ajuste automático de fronteira, a posição da linha de grade será ajustada de acordo com os altos e baixos dos preços recentes ou a média móvel definida para otimizar o layout da grade.

Através dos princípios acima, a estratégia permite a compra e venda automática em situações de volatilidade de preços, e ajusta os pontos de vantagem de acordo com a tendência, aumentando assim o lucro geral.

Análise de vantagens

A estratégia de grelha dinâmica tem as seguintes vantagens:

  1. A adaptabilidade é grande. Pode ser adaptado a diferentes mercados e variedades por meio de configurações de parâmetros, e tem uma boa adaptabilidade a situações de choque.

  2. Alta automação. Como a estratégia é baseada em uma lógica matemática rigorosa, o ponto de equilíbrio do posicionamento é definido, portanto, é possível realizar negociações totalmente automatizadas, reduzindo a interferência de emoções subjetivas.

  3. Risco controlado. Ao definir parâmetros como o número de grades, os limites da grelha, etc., é possível controlar efetivamente a abertura de risco de cada transação, mantendo assim o risco geral dentro de limites aceitáveis.

  4. Adaptabilidade a tendências. A função de ajuste dinâmico dos limites da grelha foi adicionada à estratégia, permitindo que a grelha seja otimizada para acompanhar as tendências de preços, aumentando a lucratividade em condições de tendências.

  5. Estabilidade na taxa de vitória. Como a rede de negociação é essencialmente uma estratégia de alta e baixa freqüência durante oscilações de preços, a estratégia pode ser rentável enquanto os preços se mantiverem, portanto, tem uma alta taxa de vitória a longo prazo.

Análise de Riscos

Embora as vantagens desta estratégia sejam óbvias, há também alguns riscos:

  1. Risco de tendência. Se um forte movimento unilateral de preços for ultrapassado, o espaço de lucro da estratégia será limitado e poderá enfrentar um retorno maior.

  2. A estratégia tem muitos parâmetros, incluindo o número de grades, limites iniciais, limites dinâmicos, etc. A combinação de diferentes parâmetros tem um grande impacto no desempenho da estratégia, e a dificuldade de otimização real não é pequena.

  3. A estratégia de grelha é essencialmente uma estratégia de alta frequência, com a construção de posições muito freqüentes, o que significa custos de negociação mais elevados e potencial risco de deslizamento.

  4. A estratégia é fortemente dependente de situações de choque, e é provável que a estratégia enfrente uma grande retração se o preço entrar em uma tendência unilateral rápida.

Em relação a esses riscos, pode-se começar a melhorar a partir dos seguintes aspectos: adicionar indicadores de determinação de tendências como condições de filtragem para a iniciação da estratégia, otimizar o espaço e o método de pesquisa de parâmetros, introduzir a lógica de controle de gestão de fundos e posições, aumentar a lógica de ruptura de tendências. Através dessas otimizações, a estabilidade e a lucratividade da estratégia podem ser melhoradas.

Direção de otimização

Com base na análise acima, a estratégia tem como principais direções de otimização:

  1. Introduzir condições de filtragem de tendência ❚ Adicionar indicadores de determinação de tendência, como médias móveis, ADX, etc., antes do início da estratégia. Iniciar a estratégia apenas em situações de choque, e manter a expectativa em situações de tendência, para evitar efetivamente o risco de retração em situações de tendência.

  2. Busca de parâmetros de otimização. Utilize algoritmos inteligentes para otimizar parâmetros de grelha, como algoritmos genéticos, algoritmos de grupos de partículas, etc., para encontrar automaticamente a combinação de parâmetros ótimos, aumentando a eficiência e a qualidade da otimização.

  3. Aumentar a lógica de controle de risco. Adicionar mais lógica de controle de risco à estratégia, como ajustar a largura da grelha de acordo com a dinâmica da flutuação dos preços, definir o limite máximo de retirada para disparar a posição de equilíbrio, etc., para melhor controlar o risco.

  4. Introduzir um stop loss de tendência. Configurar uma tendência para quebrar a linha de stop loss, como uma determinada proporção na borda da grade, e, uma vez que o preço quebra a linha de stop loss, a posição é totalmente plana, evitando uma grande retração sob a tendência.

  5. Otimização da execução de transações. Otimização dos elementos de execução de transações, como a adoção de algoritmos de lista de condições e ordens mais avançados, reduzindo a frequência e os custos de transação, aumentando a eficiência da execução.

Com essas otimizações, a adaptabilidade, robustez e rentabilidade da estratégia podem ser ampliadas, tornando-a mais próxima das necessidades do mercado.

Resumir

Em geral, a estratégia de rastreamento de tendências da grelha dinâmica é uma estratégia de negociação de média e alta frequência baseada no princípio de negociação de grelha e, ao mesmo tempo, integra o mecanismo de ajuste dinâmico e adaptação de tendências. Sua vantagem é a forte adaptabilidade, alto nível de automação, controle de risco, boa adaptação à tendência, estabilidade de taxa de vitória, etc., mas também existe um forte risco de risco de tendência, dificuldade de otimização de parâmetros, frequência de negociação e dependência de condições de comportamento.

A ideia de negociação de grades é uma metodologia de quantificação relativamente madura e prática, que permite estender e desenvolver as vantagens da negociação de grades clássica com a adição de mecanismos de otimização dinâmica e adaptação à tendência da estratégia. Oferece aos investidores uma nova ideia e possibilidade de negociação de quantificação em situações de turbulência. Com mais otimização e melhorias, a estratégia promete ser uma excelente ferramenta de negociação de quantificação de alta e média frequência.

Código-fonte da estratégia
/*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)