Estratégia de negociação de redes inteligentes adaptativas

Autora:ChaoZhang, Data: 2024-01-16 14:51:48
Tags:

Resumo

Esta estratégia é uma estratégia de negociação de rede inteligente adaptativa baseada na plataforma TradingView, escrita em Pine Script v4.

Estratégia lógica

Características fundamentais

Pirâmide e Gestão do Dinheiro:
- Permite até 14 adições na mesma direcção (piramida),
- Utiliza uma estratégia baseada em liquidez para gerir o tamanho das posições,
- O capital inicial é fixado em 100 USD para fins de simulação,
- Uma pequena comissão de 0,1% é cobrada por cada transacção.
Limites da grade:
- Os utilizadores podem optar por utilizar limites calculados automaticamente ou definir manualmente os limites superior e inferior da grade,
- Os limites automáticos podem ser derivados do recente Alto e Baixo do preço ou de uma média móvel simples (SMA),
- Os utilizadores podem definir o período de revisão para o cálculo dos limites e ajustar o desvio para alargar ou reduzir os limites.
Linhas da grade:
- A estratégia permite um número personalizável de linhas de rede dentro dos limites, com um intervalo recomendado entre 3 e 15,
- As linhas da grade estão uniformemente espaçadas entre os limites superior e inferior.

Estratégia lógica

Inscrição:
- O script coloca ordens de compra quando o preço cai abaixo de uma linha de grade e nenhuma ordem existente está associada a essa linha de grade.
- Cada quantidade de ordem de compra é calculada com base no capital inicial dividido pelo número de linhas da rede, ajustado para o preço corrente.
Saída:
- As ordens de venda são acionadas quando o preço sobe acima de uma linha de rede, desde que exista uma ordem aberta correspondente à próxima linha inferior de rede.
Grelha adaptativa:
- Se for definido em limites automáticos, a rede se adapta às condições de mercado em mudança recalculando os limites superior e inferior e ajustando a rede em conformidade.

Análise das vantagens

A estratégia integra a natureza sistemática e a execução eficiente da negociação de rede. Permitindo a pirâmide e usando a gestão de dinheiro pode controlar efetivamente os riscos. A rede de adaptação automática se adapta a diferentes condições de mercado. Os parâmetros ajustáveis atendem a diferentes estilos de negociação.

Análise de riscos

Uma quebra de preço além dos limites da rede pode causar perdas graves. Os parâmetros devem ser ajustados adequadamente ou combinados com um stop loss para controlar os riscos. Além disso, a negociação excessiva aumenta os custos de transação.

Orientações de otimização

Considere a combinação com um filtro de tendência ou a otimização dos parâmetros da grade.

Conclusão

Esta estratégia gera sistematicamente entradas e saídas ao gerenciar posições. Através do ajuste de parâmetros, ele se adapta a diferentes preferências. Ele combina a natureza baseada em regras da negociação de rede com a flexibilidade da negociação de tendências, facilitando a complexidade da operação mantendo a robustez.

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

Mais.