
La estrategia de comercio de la grilla de adaptación es una estrategia cuantitativa basada en el sistema de comercio de la grilla, que se adapta a los cambios en el mercado mediante el ajuste automático de la posición de la línea de la grilla. La estrategia utiliza varios indicadores técnicos para calcular los mejores puntos de negociación y actualizar la grilla de forma dinámica según los cambios en los precios. La idea central es ejecutar operaciones de compra o venta dentro de un rango de precios establecido, cuando el precio toca la línea de la grilla predeterminada, para capturar las oportunidades de ganancia generadas por las fluctuaciones del mercado. La estrategia se caracteriza por su mecanismo de elasticidad y los parámetros de latencia, que permiten que la grilla se ajuste automáticamente para adaptarse a diferentes entornos del mercado y lograr una ejecución de transacciones más flexible.
La estrategia se basa en los siguientes componentes centrales y principios de trabajo:
Mecanismo de tratamiento suave: La estrategia primero se trata de la suavización de los precios, soporta varios tipos de promedios móviles (retroceso lineal, SMA, EMA, VWMA y TEMA), los usuarios pueden elegir el método de suavización adecuado según sus preferencias.
Parámetros de retrasoEsta es la innovación clave de la estrategia, que se actualiza la señal de filtrar eficazmente el ruido del mercado mediante la introducción de la función de retardo lz ((), que sólo se actualiza cuando el cambio de precio supera un cierto porcentaje.
Mecanismo de construcción de la rejilla:
Logía de generación de señales:
Mecanismo de control de las transacciones:
Actualización de la red dinámicaCuando el promedio móvil lento (LMA) cambia, la estructura de la red se reajusta para que la estrategia se adapte a la nueva franja de precios.
La estrategia utiliza una matriz para almacenar los precios de las líneas de la red, para determinar el punto de compra y venta específico mediante el cálculo de los precios y la intersección de las líneas de la red, y considera una variedad de restricciones para evitar transacciones innecesarias.
La adaptabilidadLa mayor ventaja de esta estrategia es la capacidad de ajustar automáticamente la posición de la rejilla en función de los cambios en el mercado, sin necesidad de intervención humana. A través de los parámetros de elasticidad y el mecanismo de ajuste de los puntos de referencia, la rejilla puede moverse con los cambios en la tendencia de los precios, manteniéndose siempre relevante.
Filtrado de ruidoLa introducción del parámetro de retardo Laziness es una innovación que asegura que el ajuste de la grilla se desencadene solo cuando el cambio de precio es lo suficientemente significativo, lo que reduce efectivamente la respuesta al ruido del mercado y aumenta la estabilidad de la estrategia.
Flexible y personalizadoLa estrategia ofrece una gran cantidad de configuraciones de parámetros, incluyendo el número de grillas, el intervalo de grillas, las preferencias de dirección, el tipo de suavizado, etc., que el usuario puede ajustar según las diferentes características del mercado y el estilo de negociación personal.
Zonas de negociación visualizadas: La estrategia muestra las zonas de negociación activas en ese momento a través de un relleno de color, lo que permite a los comerciantes ver intuitivamente dónde se encuentra el precio actual en la grilla, para facilitar la toma de decisiones.
Control de riesgosLa estrategia establece un mecanismo natural de control de riesgos para evitar transacciones desfavorables en condiciones extremas de mercado, al limitar las transacciones a una red específica.
Logía de entrada y salida unificada: El uso de la misma línea de la red como señal de compra y venta, mantiene la consistencia y la previsibilidad de la lógica de transacción.
Riesgo de ruptura de barrera: La estrategia es esencialmente una estrategia de negociación por rangos, con la posibilidad de sufrir pérdidas continuas en un mercado de fuerte tendencia. La estrategia puede aumentar continuamente la posición en la dirección equivocada cuando el precio rompe el límite inferior de la red y continúa moviéndose en un solo sentido. La solución es agregar un componente de identificación de tendencias o suspender la negociación de la red cuando se confirma la formación de una tendencia.
Sensibilidad de los parámetros: El rendimiento de la estrategia depende en gran medida de la configuración de los parámetros, especialmente el parámetro de retardo (Laziness) y el parámetro de elasticidad (Elasticity). Los parámetros inadecuados pueden causar ajustes de la red que no son oportunos o excesivamente sensibles. Se recomienda optimizar estos parámetros mediante la retroalimentación en diferentes entornos de mercado.
El riesgo de una posición piramidal: La estrategia permite múltiples entradas en la misma dirección (pyramiding = 4), lo que puede conducir a un exceso de apalancamiento y concentración de riesgo en condiciones extremas de mercado. Se debe considerar el establecimiento de límites máximos de tenencia y la gestión dinámica de posiciones.
Punto de deslizamiento y efecto de las comisionesLas estrategias de trading de la red generalmente implican operaciones frecuentes, y en la ejecución real, los puntos de deslizamiento y las comisiones pueden afectar significativamente la rentabilidad de la estrategia. Estos factores deben ser incluidos en la retroevaluación y es posible que se necesite ajustar el intervalo de la red para equilibrar la frecuencia de las operaciones con los costos.
Tratamiento de conflictos de señales: Cuando las señales de compra y venta aparecen simultáneamente, la estrategia actual elige ignorar las dos señales, lo que puede conducir a perder oportunidades de negociación importantes. Se puede considerar la solución de conflictos de señales basados en indicadores de mercado adicionales o en modelos de precios.
Ajuste de los parámetros de adaptación: Las estrategias pueden optimizarse aún más para ajustar automáticamente el intervalo de la cuadrícula y los parámetros de retardo en función de la volatilidad del mercado. Por ejemplo, aumentar el intervalo de la cuadrícula en mercados de alta volatilidad y reducir el intervalo de la cuadrícula en mercados de baja volatilidad, lo que permite que las estrategias se adapten mejor a las diferentes condiciones del mercado.
Integración de componentes de reconocimiento de tendenciasLas estrategias actuales pueden no funcionar bien en un mercado de tendencia y pueden introducir indicadores de identificación de tendencia (como ADX, cruce de medias móviles, etc.) para ajustar automáticamente la dirección de la negociación o suspender la negociación de la red cuando se identifica una tendencia fuerte.
Gestión de posiciones dinámicasLa estrategia actual utiliza el tamaño de la posición fija, que puede ser mejorada para la gestión de posiciones dinámicas basadas en el cálculo del riesgo, por ejemplo, el tamaño de la posición se ajusta en función de la ATR, o se distribuyen los fondos en función del porcentaje de valor neto de la cuenta.
Análisis de marcos de tiempo múltiples: Introducción de análisis de múltiples marcos de tiempo, que utiliza la dirección de la tendencia de períodos de tiempo más largos para filtrar las señales de negociación y ejecutar operaciones de la red sólo en la dirección de la tendencia de marcos de tiempo más grandes.
Mecanismo de stop loss perfecto: La estrategia actual carece de un mecanismo de stop loss claro, se puede agregar un stop global basado en la situación general del mercado, o establecer puntos de stop loss separados para cada nivel de la red para limitar la pérdida máxima de una sola operación.
Optimización del tiempo de entrada y salida: La estrategia puede integrar indicadores de volumen de tráfico o de movimiento de precios para optimizar el tiempo de entrada y salida específico mediante condiciones de filtración adicionales cuando se activa la señal de la red, lo que mejora la tasa de éxito.
Integración del aprendizaje automático: Se puede considerar optimizar la posición de la red y la selección de parámetros utilizando algoritmos de aprendizaje automático, y predecir la configuración óptima de la red a través de modelos de entrenamiento de datos históricos, para mejorar aún más la adaptabilidad de la estrategia.
La estrategia de comercio de la rejilla adaptable resuelve la falta de flexibilidad de la estrategia de comercio de la rejilla tradicional a través de una función de retardo innovadora y un mecanismo de ajuste dinámico. Es capaz de adaptarse automáticamente a los cambios en el mercado, capturar oportunidades de comercio en diferentes rangos de precios, mientras controla el comportamiento de comercio a través de varios parámetros.
A pesar de los problemas potenciales, como el riesgo de ruptura de la franja y la sensibilidad de los parámetros, la estrategia tiene el potencial de obtener un rendimiento estable en una variedad de entornos de mercado mediante la integración de direcciones de optimización, como la identificación de tendencias y el ajuste de parámetros dinámicos. En la práctica, se recomienda verificar el rendimiento de la estrategia mediante una revisión exhaustiva, especialmente en diferentes condiciones de mercado, y ajustar los parámetros según las características de las variedades de comercio específicas para obtener el mejor resultado.
//@version=5
// This source code is subject to the terms of the Mozilla Public License 2.0 https://mozilla.org/MPL/2.0/
// ©mvs1231 || xxattaxx
strategy(title='Grid Bot Auto Strategy', shorttitle='GridBot', initial_capital = 100000, overlay=true, pyramiding=4, default_qty_type = strategy.fixed, default_qty_value = 0, commission_value = 0.04, commission_type = strategy.commission.percent, margin_long = 0, margin_short = 0, process_orders_on_close = true)
//----<User Inputs>------------------------------------------------------------------------------//
iLen = input.int(7, 'Smoothing Length(7)', minval=1)
iMA = input.string('lreg', 'Smoothing Type', options=['lreg', 'sma', 'ema', 'vwma', 'tema'])
iLZ = input.float(4.0, 'Laziness(4%)', step=.25) / 100
iELSTX = input(50.0, 'Elasticity(50)')
iGI = input.float(2.0, 'Grid Interval(2%)', step=.25) / 100
iGrids = input.int(6, 'Number of Grids', options=[2, 4, 6, 8])
iCool = input.int(2, 'Cooldown(2)', minval=0)
iDir = input.string('neutral', 'Direction', options=['neutral', 'up', 'down'])
iGT = input.int(70, 'Grid Line Transparency(100 to hide)', minval=0, maxval=100)
iFT = input.int(90, 'Fill Transparency(100 to hide)', minval=0, maxval=100)
iSS = input.string('small', 'Signal Size', options=['small', 'large'])
iReset = input(true, 'Reset Buy/Sell Index When Grids Change')
iEXTR = input(true, 'Use Highs/Lows for Signals')
iMT = input(true, 'Show Min Tick')
iRFC = input(false, 'Reverse Fill Colors')
qty_ent = iGrids/2
qty_pos = strategy.initial_capital / qty_ent / 2 / open
//----<Colors>-----------------------------------------------------------------------------------//
RedGrid = color.new(color.red, iGT)
GreenGrid = color.new(color.green, iGT)
Crimson = #DC143C
LimeGreen = #32CD32
//----<Variables>--------------------------------------------------------------------------------//
NextUP = 0.0
NextDN = 0.0
LastSignal = 0
LastSignal_Index = 0
AP = 0.0
G = iGrids
Buy = false
Sell = false
UpperLimit = 0.0
LowerLimit = 0.0
SignalLine = 0.0
CurrentGrid = 0.0
BuyLine = 0.0
SellLine = 0.0
DIR = 0
MeaningOfLife = 42
//----<Calculations>-----------------------------------------------------------------------------//
//Lazy Formula
lz(x, lzf) =>
LZ = 0.0
s = math.sign(x)
LZ := x == nz(x[1], x) ? x : x > nz(LZ[1] + lzf * LZ[1] * s, x) ? x : x < nz(LZ[1] - lzf * LZ[1] * s, x) ? x : LZ[1]
LZ
//Smoothing
LR = ta.linreg(close, iLen, 0)
SMA = ta.sma(close, iLen)
EMA = ta.ema(close, iLen)
VWMA = ta.vwma(close, iLen)
TEMA = ta.ema(ta.ema(ta.ema(close, iLen), iLen), iLen)
MA = iMA == 'lreg' ? LR : iMA == 'sma' ? SMA : iMA == 'ema' ? EMA : iMA == 'vwma' ? VWMA : TEMA
//Make Lazy
LMA = lz(MA, iLZ)
//Calculate Elasticity
ELSTX = syminfo.mintick * iELSTX
//Show Mintick
if iMT and barstate.islast
table.cell(table.new(position.top_right, 1, 1), 0, 0, str.tostring(syminfo.mintick))
//Anchor Point
AP := MA > LMA ? AP[1] + ELSTX : MA < LMA ? AP[1] - ELSTX : AP[1]
AP := AP >= NextUP[1] ? NextUP[1] : AP
AP := AP <= NextDN[1] ? NextDN[1] : AP
//Reset if Next Level Reached or AP is crossed
AP := LMA != LMA[1] ? LMA : AP
//Next Gridlines
NextUP := LMA != LMA[1] ? LMA + LMA * iGI : NextUP[1]
NextDN := LMA != LMA[1] ? LMA - LMA * iGI : NextDN[1]
//Grid Interval
GI = AP * iGI
//----<Grid Array>-------------------------------------------------------------------------------//
a_grid = array.new_float(9)
for x = -4 to 4 by 1
array.set(a_grid, x + 4, AP + GI * x)
Get_Array_Values(ArrayName, index) =>
value = array.get(ArrayName, index)
value
//----<Set Static Grids>-------------------------------------------------------------------------//
G0 = Get_Array_Values(a_grid, 0) //Upper4
G1 = Get_Array_Values(a_grid, 1) //Upper3
G2 = Get_Array_Values(a_grid, 2) //Upper2
G3 = Get_Array_Values(a_grid, 3) //Upper1
G4 = Get_Array_Values(a_grid, 4) //Center
G5 = Get_Array_Values(a_grid, 5) //Lower1
G6 = Get_Array_Values(a_grid, 6) //Lower2
G7 = Get_Array_Values(a_grid, 7) //Lower3
G8 = Get_Array_Values(a_grid, 8) //Lower4
//----<Set Upper and Lower Limits>---------------------------------------------------------------//
UpperLimit := G >= 8 ? G8 : G >= 6 ? G7 : G >= 4 ? G6 : G5
LowerLimit := G >= 8 ? G0 : G >= 6 ? G1 : G >= 4 ? G2 : G3
//----<Calculate Signals>------------------------------------------------------------------------//
Get_Signal_Index() =>
Value = 0.0
Buy_Index = 0
Sell_Index = 0
start = 4 - G / 2
end = 4 + G / 2
for x = start to end by 1
Value := Get_Array_Values(a_grid, x)
if iEXTR
Sell_Index := low[1] < Value and high >= Value ? x : Sell_Index
Buy_Index := high[1] > Value and low <= Value ? x : Buy_Index
Buy_Index
else
Sell_Index := close[1] < Value and close >= Value ? x : Sell_Index
Buy_Index := close[1] > Value and close <= Value ? x : Buy_Index
Buy_Index
[Buy_Index, Sell_Index]
[BuyLine_Index, SellLine_Index] = Get_Signal_Index()
//----<Signals>----------------------------------------------------------------------------------//
Buy := BuyLine_Index > 0 ? true : Buy
Sell := SellLine_Index > 0 ? true : Sell
//No repeat trades at current level
Buy := low >= SignalLine[1] - GI ? false : Buy
Sell := high <= SignalLine[1] + GI ? false : Sell
//No trades outside of grid limits
Buy := close > UpperLimit ? false : Buy
Buy := close < LowerLimit ? false : Buy
Sell := close < LowerLimit ? false : Sell
Sell := close > UpperLimit ? false : Sell
//Direction Filter (skip one signal if against market direction)
DIR := iDir == 'up' ? 1 : iDir == 'down' ? -1 : 0
Buy := DIR == -1 and low >= SignalLine[1] - GI * 2 ? false : Buy
Sell := DIR == 1 and high <= SignalLine[1] + GI * 2 ? false : Sell
//Conflicting Signals
if Buy and Sell
Buy := false
Sell := false
LastSignal_Index := LastSignal_Index[1]
LastSignal_Index
//----<Cooldown>---------------------------------------------------------------------------------//
y = 0
for i = 1 to iCool by 1
if Buy[i] or Sell[i]
y := 0
break
y += 1
y
CoolDown = y
Buy := CoolDown < iCool ? false : Buy
Sell := CoolDown < iCool ? false : Sell
//----<Trackers>---------------------------------------------------------------------------------//
LastSignal := Buy ? 1 : Sell ? -1 : LastSignal[1]
LastSignal_Index := Buy ? BuyLine_Index : Sell ? SellLine_Index : LastSignal_Index[1]
SignalLine := Get_Array_Values(a_grid, LastSignal_Index)
//Reset to Center Grid when LMA changes
if iReset
SignalLine := LMA < LMA[1] ? UpperLimit : SignalLine
SignalLine := LMA > LMA[1] ? LowerLimit : SignalLine
SignalLine
BuyLine := Get_Array_Values(a_grid, BuyLine_Index)
SellLine := Get_Array_Values(a_grid, SellLine_Index)
//----<Plot Grids>--------------------------//
color apColor = na
apColor := MA < AP ? color.new(color.red, iGT) : MA > AP ? color.new(color.green, iGT) : apColor[1]
apColor := LMA != LMA[1] ? na : apColor
plot(G >= 8 ? G0 : na, color=GreenGrid)
plot(G >= 6 ? G1 : na, color=GreenGrid)
plot(G >= 4 ? G2 : na, color=GreenGrid)
plot(G >= 2 ? G3 : na, color=GreenGrid)
plot(G4, color=apColor, linewidth=4) // Center
plot(G >= 2 ? G5 : na, color=RedGrid)
plot(G >= 4 ? G6 : na, color=RedGrid)
plot(G >= 6 ? G7 : na, color=RedGrid)
plot(G >= 8 ? G8 : na, color=RedGrid)
//fill
LineAbove = SignalLine == UpperLimit ? SignalLine : SignalLine + GI
LineBelow = SignalLine == LowerLimit ? SignalLine : SignalLine - GI
a = plot(LineAbove, color=color.new(color.red, 100), style=plot.style_circles)
b = plot(LineBelow, color=color.new(color.green, 100), style=plot.style_circles)
boxColor = LastSignal == 1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
if iRFC
boxColor := LastSignal == -1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
boxColor
fill(a, b, color=boxColor)
//----<Plot Signals>-----------------------------------------------------------------------------//
plotchar(Buy and iSS == 'small', 'Buy', color=color.new(LimeGreen, 0), size=size.tiny, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'small', 'Sell', color=color.new(Crimson, 0), size=size.tiny, location=location.abovebar, char='▼')
plotchar(Buy and iSS == 'large', 'Buy', color=color.new(LimeGreen, 0), size=size.small, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'large', 'Sell', color=color.new(Crimson, 0), size=size.small, location=location.abovebar, char='▼')
//----<Alerts>-----------------------------------------------------------------------------------//
alertcondition(condition=Buy, title='buy', message='buy')
alertcondition(condition=Sell, title='sell', message='sell')
//-----------------------------------------------------------------------------------------------//
if strategy.position_size >= 0 and Buy
strategy.entry("Long", strategy.long, qty = qty_pos)
if strategy.position_size <= 0 and Sell
strategy.entry("Short", strategy.short, qty = qty_pos)
if strategy.position_size > 0 and Sell
strategy.close("Long", qty = qty_pos)
if strategy.position_size < 0 and Buy
strategy.close("Short", qty = qty_pos)