Estrategia de cobertura del riesgo de negociación en red

El autor:¿ Qué pasa?, Fecha: 2024-03-27 18:15:12
Las etiquetas:

img

Resumen de la estrategia

La estrategia de cobertura de riesgo de comercio en red es una estrategia de comercio cuantitativa basada en el concepto de comercio en red, combinada con la idea de cobertura de riesgo. La estrategia establece múltiples órdenes de compra y venta dentro de un rango de precios predefinido para beneficiarse de las fluctuaciones de precios. Al mismo tiempo, la estrategia introduce un mecanismo de cobertura de riesgo que ajusta dinámicamente los límites de la red para adaptarse a los cambios en el entorno del mercado y reducir los riesgos de la estrategia.

Principio de la estrategia

El principio básico de esta estrategia es la negociación en red. Primero, en base a los parámetros establecidos por el usuario, se determinan los límites superior e inferior de la red y el número de líneas de red. Luego, se colocan órdenes de compra y venta en las líneas de red: cuando el precio toca una línea de red, si no hubo orden en esa línea de red antes, se abre una posición; si hubo una orden antes, la posición se cierra. De esta manera, la estrategia puede abrir y cerrar continuamente posiciones en fluctuaciones de precios para obtener ganancias.

Al mismo tiempo, para reducir los riesgos, la estrategia introduce un mecanismo de ajuste dinámico de los límites de la red. De acuerdo con la elección del usuario, los límites superior e inferior de la red pueden ajustarse automáticamente de dos maneras: 1) basándose en los precios más altos y más bajos en el período reciente, considerando la desviación establecida por el usuario; 2) basándose en la línea media móvil, considerando la desviación establecida por el usuario. Al ajustar dinámicamente los límites de la red, la red siempre puede centrarse alrededor del precio actual, reduciendo así el riesgo de que el precio rompa los límites de la red.

Además, al abrir una posición, la estrategia divide los fondos totales en N partes iguales, y cada vez que abre una posición, utiliza una cantidad igual de fondos, lo que puede reducir el riesgo de una sola transacción.

Análisis de ventajas

  1. Gran adaptabilidad: Al ajustar dinámicamente los límites de la red, la estrategia puede adaptarse a diferentes entornos de mercado.

  2. Riesgo controlable: la estrategia utiliza cantidades iguales de fondos al abrir posiciones, por lo que el riesgo de una sola transacción es pequeño; al mismo tiempo, el mecanismo dinámico de ajuste de los límites de la red puede reducir el riesgo de que los precios rompan los límites de la red.

  3. Alta frecuencia de negociación: Dado que la red suele tener muchos pedidos, la frecuencia de negociación es alta, lo que facilita obtener ganancias en mercados volátiles.

  4. Parámetros flexibles: Los usuarios pueden establecer el número de cuadrículas, los límites superior e inferior, los parámetros de ajuste dinámico, etc. de acuerdo con sus preferencias, adaptándose así a diferentes estilos de negociación.

Análisis de riesgos

  1. Si el precio continúa subiendo o bajando unilateralmente, rompiendo los límites de la red, y el ajuste dinámico no puede mantenerse al día con la velocidad de los cambios de precios, la estrategia puede enfrentar mayores riesgos.

  2. Comisiones de transacción: Dado que la estrategia tiene una alta frecuencia de negociación, las comisiones de transacción pueden tener cierto impacto en los rendimientos.

  3. Ajustes incorrectos de parámetros: si los parámetros se establecen incorrectamente, como demasiadas líneas de red o ajustes irracionales de los límites de la red, puede dar lugar a un mal rendimiento de la estrategia.

Soluciones: 1) En los mercados de tendencia, considere aumentar el rango de ajuste de los límites de la red o combinarlo con las estrategias de tendencia; 2) Elija bolsas y monedas con tarifas de transacción más bajas; 3) Antes de la operación real, los parámetros deben ser completamente revisados y optimizados.

Direcciones de optimización

  1. Combinar con otras estrategias: Considere combinar las estrategias de negociación de red con otros tipos de estrategias, como estrategias de tendencia, estrategias de reversión media, etc., para mejorar la adaptabilidad y la estabilidad de la estrategia.

  2. Mejorar el mecanismo de ajuste dinámico: El mecanismo de ajuste dinámico actual de la estrategia es relativamente simple y puede optimizarse aún más, por ejemplo, teniendo en cuenta más factores (como el volumen de operaciones, la volatilidad, etc.) y adoptando algoritmos más avanzados (como algoritmos adaptativos, algoritmos de aprendizaje automático, etc.).

  3. Optimizar la gestión de fondos: actualmente, la estrategia adopta la gestión de fondos igualitarios. Podemos considerar la introducción de métodos de gestión de fondos más avanzados, como el Criterio Kelly, métodos de optimización, etc., para mejorar aún más la eficiencia de utilización de fondos y los rendimientos.

  4. Introducir tomar ganancias y detener pérdidas: sobre la base de la negociación en red, se puede introducir una lógica de tomar ganancias y detener pérdidas, como moverse tomar ganancias y detener pérdidas, volatilidad tomar ganancias y detener pérdidas, etc., para reducir aún más los riesgos de la estrategia.

Resumen de las actividades

La estrategia de cobertura de riesgo de comercio en red es una estrategia de comercio cuantitativa altamente automatizada, adaptable y controlada por el riesgo. A través del comercio en red y el ajuste dinámico de la red, la estrategia puede obtener ganancias en varias condiciones de mercado mientras controla los riesgos. Sin embargo, la estrategia puede tener un mal rendimiento en los mercados de tendencia y las tarifas de transacción pueden afectar los rendimientos. Por lo tanto, se necesita una mayor optimización y mejora en las aplicaciones prácticas.


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

Más.