Baseado na estratégia de rede dinâmica adaptativa longa-curta


Data de criação: 2024-03-19 14:19:12 última modificação: 2024-03-19 14:19:28
cópia: 0 Cliques: 925
1
focar em
1617
Seguidores

Baseado na estratégia de rede dinâmica adaptativa longa-curta

Visão geral

Esta é uma estratégia de negociação de grelha dinâmica auto-adaptável em vários espaços escrita com base em Pine Script. A ideia central da estratégia é calcular automaticamente o limite superior e inferior de uma grade com base nos altos e baixos mais recentes dos preços ou na média móvel simples, e dividir esse intervalo em várias linhas de grade. Quando o preço toca uma linha de grade, a posição é aberta ou fechada.

Princípio da estratégia

  1. Calcule o limite superior e inferior da grelha. Dependendo da escolha do usuário, o limite superior e inferior pode ser baseado nos pontos mais altos e mais baixos da linha N-K mais recente, e pode ser configurado para ampliar ou diminuir a porcentagem; ou pode ser baseado na média móvel simples do preço de fechamento da linha N-K mais recente, e pode ser configurado como um percentual de desvio para cima e para baixo.

  2. Gerar uma matriz de linhas de grelha. Dividir o alcance da grelha de acordo com o número de linhas de grelha definidas, gerando uma matriz de linhas de grelha correspondente ao preço.

  3. A entrada/acréscimo de posições. Se o preço de fechamento atual for menor do que o preço de uma linha de grelha e a linha de grelha ainda não tiver uma posição, a posição será aberta nessa posição. Assim, o acréscimo de posições continuará quando o preço tocar a linha de grelha mais alta.

  4. Sair/reduzir a posição. Caminhar de cima para baixo pela linha de grade, se o preço de fechamento atual for maior do que o preço de uma linha de grade e a linha de grade inferior tiver uma posição, elimine o múltiplo da linha de grade inferior. Assim, a redução de posição continuará quando o preço voltar.

  5. Ajuste dinâmico. Se você escolher o recurso de grade dinâmica, cada linha K recomputará o limite superior e inferior da grade e a matriz de linhas da grade, permitindo que a grade se adapte continuamente à mudança de cenário.

Análise de vantagens

  1. A estratégia de negociação de grelha é capaz de se adaptar a situações de choque e tendência. Em situações de choque, a estratégia de grelha pode continuar abrindo posições baixas, ganhando diferença de preço; em situações de tendência, a grelha segue o movimento do preço, e pode manter uma certa posição, obtendo ganhos de tendência.

  2. Risco controlado. O tamanho da posição de cada posição aberta é determinado pelo número de grades configuradas, a abertura de risco individual é pequena e controlada. Ao mesmo tempo, a posição de liquidação ganha lucro quando o preço toca a linha de grade superior, e também protege os potenciais prejuízos até certo ponto.

  3. A estratégia é basicamente totalmente automática, sem a necessidade de intervenção humana, e é adequada para investidores que precisam de retornos estáveis e de longo prazo.

  4. Parâmetros flexíveis. O usuário pode ajustar o número de linhas de grelha de acordo com as características do mercado, os parâmetros de grelha dinâmica, etc., para otimizar o desempenho da estratégia.

Análise de Riscos

  1. Risco de Cisne Negro. Se houver uma queda extrema do mercado, o preço salta diretamente para o mínimo abaixo da linha de grade, a estratégia estará cheia e enfrentará uma grande retirada. Para reduzir esse risco, pode-se definir uma condição de parada de perda, e a perda será totalmente eliminada.

  2. Se a grelha for muito densa, a diferença de preço de cada posição aberta será pequena, e os encargos podem corroer a maior parte do lucro. Se a grelha for muito ampla, a proporção de abertura de posição única é alta, com uma grande abertura de risco. É necessário avaliar cuidadosamente as características dos ativos do indicador e escolher o parâmetro da grelha adequado.

  3. Risco de diferença de base. Esta estratégia é baseada em condições de abertura de posição livre no preço atual. Em mercados como futuros, se o preço do contrato for maior do que o preço de referência, o preço de abertura de posição livre pode ser maior do que o esperado.

Direção de otimização

  1. A estratégia de grade pode ser usada como um filtro, como ativar a grade apenas quando o ADX está abaixo de um determinado limite, e fechar a grade quando a tendência é evidente, mantendo apenas posições unilaterais.

  2. Optimização de sinais. Pode-se sobrepor outros sinais na base da grade, como a grade + a linha média, ou seja, é a grade que decide abrir posições de baixa, mas quando o preço atravessa uma certa linha média, a posição é aberta, caso contrário não é aberta.

  3. Gerenciamento de posições. Atualmente, a estratégia de posições por bloco é fixa e pode ser configurada para reduzir adequadamente as posições por bloco quando o preço está longe do preço médio do mercado, aumentando as posições quando estão perto do preço médio do mercado, aumentando a eficiência do uso de fundos.

  4. A densidade da grade é adaptada. A densidade da grade é ajustada de acordo com a flutuação dos preços, aumentando o número de grades quando a flutuação é alta e reduzindo o número de grades quando a flutuação é baixa. Isso pode otimizar a largura da grade e melhorar a utilização de fundos.

Resumir

A estratégia é uma estratégia de quantificação de linha média de longo prazo, com forte adaptabilidade, através da adaptação da grade dinâmica, com a capacidade de abrir e fechar posições frequentemente para ganhar prejuízos em situações de turbulência e manter uma certa direção de ruptura para obter ganhos de tendência em situações de tendência. Com a lógica e o gerenciamento de posições de gatilho da grade razoavelmente configurada, é possível obter ganhos estáveis.

Código-fonte da estratégia
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © jcloyd

//@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)