Estrategia de cobertura de riesgos de operaciones en red


Fecha de creación: 2024-03-27 18:15:12 Última modificación: 2024-03-27 18:15:12
Copiar: 0 Número de Visitas: 670
1
Seguir
1166
Seguidores

Estrategia de cobertura de riesgos de operaciones en red

Descripción general de la estrategia

La estrategia de cobertura de riesgo de la cuadrícula es una estrategia de comercio cuantitativa basada en la idea de la cuadrícula de comercio, combinada con la idea de la cobertura de riesgo. La estrategia se beneficia de la fluctuación de los precios mediante la colocación de múltiples órdenes de compra y venta dentro de un rango de precios predeterminado.

Principio de estrategia

El principio central de esta estrategia es el comercio de la grilla. En primer lugar, se determina el límite superior y inferior de la grilla y el número de líneas de la grilla según los parámetros establecidos por el usuario. Luego, se colocan órdenes de compra y venta en la línea de la grilla: si no hay órdenes antes de que el precio toque la línea de la grilla, se abre una posición; si hay órdenes antes, se cierra la posición. De esta manera, la estrategia puede abrir y cerrar posiciones continuas en las fluctuaciones de precios, lo que genera beneficios.

Al mismo tiempo, para reducir el riesgo, la estrategia también introdujo un mecanismo de ajuste dinámico de los bordes de la red. De acuerdo con la elección del usuario, los bordes superiores y inferiores de la red se pueden ajustar automáticamente de dos maneras: 1) de acuerdo con los precios más altos y más bajos de los últimos tiempos, y teniendo en cuenta el desplazamiento establecido por el usuario; 2) de acuerdo con las medias móviles, y teniendo en cuenta el desplazamiento establecido por el usuario.

Además, la estrategia divide el capital total en N partes al abrir una posición, y utiliza la misma cantidad de capital en cada posición, lo que reduce el riesgo de una sola transacción.

Análisis de las ventajas

  1. Adaptabilidad: Al ajustar dinámicamente los límites de la grilla, la estrategia puede adaptarse a diferentes entornos de mercado, ya sea en tendencias o situaciones de crisis, y puede ajustarse automáticamente para obtener mejores ganancias.

  2. Riesgo controlado: la estrategia utiliza la misma cantidad de capital al abrir posiciones, con un menor riesgo de transacción individual; al mismo tiempo, el mecanismo de ajuste de los límites de la red dinámica puede reducir el riesgo de que los precios rompan los límites de la red.

  3. Alta frecuencia de transacción: debido a que la red generalmente coloca más órdenes, la frecuencia de transacción es más alta y es más fácil obtener beneficios en situaciones de volatilidad.

  4. Flexibilidad de parámetros: los usuarios pueden adaptarse a diferentes estilos de negociación según sus propias preferencias, configurando el número de grillas, los límites superiores y inferiores, los parámetros de ajuste dinámico, etc.

Análisis de riesgos

  1. La estrategia puede estar en mayor riesgo si los precios continúan subiendo o bajando de manera unilateral, rompiendo los límites de la grilla, y el ajuste dinámico no sigue el ritmo de los cambios en los precios.

  2. Las comisiones pueden tener un cierto impacto en los ingresos debido a la alta frecuencia de las operaciones estratégicas.

  3. Configuración incorrecta de los parámetros: Si los parámetros se configuran incorrectamente, por ejemplo, con un número excesivo de cuadrículas, la configuración incorrecta de los límites de la cuadrícula, etc., puede causar un mal rendimiento de la política.

Soluciones: 1) En caso de tendencia, se puede considerar el aumento de la amplitud de ajuste de los límites de la cuadrícula, o en combinación con la estrategia de tendencia; 2) Seleccione las bolsas y monedas con tarifas más bajas; 3) Antes de la operación real, se requiere una adecuada evaluación y optimización de los parámetros.

Dirección de optimización

  1. Combinación con otras estrategias: se puede considerar la combinación de la estrategia de comercio de la red con otros tipos de estrategias, como la estrategia de tendencia, la estrategia de regresión a la media, etc., para mejorar la adaptabilidad y la estabilidad de la estrategia.

  2. Mejora de los mecanismos de ajuste dinámico: los mecanismos de ajuste dinámico en las estrategias actuales son relativamente simples y pueden optimizarse aún más, como considerar más factores (como el volumen de tráfico, la volatilidad, etc.) y adoptar algoritmos más avanzados (como algoritmos de adaptación, algoritmos de aprendizaje automático, etc.).

  3. Optimización de la gestión de fondos: La estrategia actual utiliza la gestión de fondos equivalentes, se puede considerar la introducción de métodos de gestión de fondos más avanzados, como la ley de Kelly, la mejor manera de optimizar, etc., para mejorar aún más la eficiencia de la utilización de fondos y los beneficios.

  4. Introducción de stop-loss: En base a la operación de la red, se pueden introducir algunas lógicas de stop-loss, como stop-loss móvil, stop-loss de volatilidad, etc., para reducir aún más el riesgo de la estrategia.

Resumir

La estrategia de cobertura de riesgo de la red es una estrategia de comercio cuantitativa de alto grado de automatización, adaptabilidad y control de riesgo. A través de la negociación en red y el ajuste dinámico de la red, la estrategia puede obtener ganancias en diversos escenarios y al mismo tiempo controlar el riesgo. Sin embargo, la estrategia puede tener un mal desempeño en situaciones de tendencia y los honorarios pueden afectar a los ingresos, por lo que se requiere una mayor optimización y mejora en la aplicación real.

Código Fuente de la Estrategia
/*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)