ianzeng123
Descripción general
La estrategia es un sistema de negociación integrado que combina un filtro de Gauss y un indicador de RSI aleatorio. La estrategia utiliza modelos matemáticos complejos para construir canales de adaptación que filtran eficazmente el ruido del mercado y capturan los cambios importantes en los precios.
Principio de estrategia
La lógica central de la estrategia se basa en los siguientes componentes clave:
- Calculación del canal de Gauss: El filtro de Gauss multiodo trata los datos de precios del HLC3 para crear un canal de adaptabilidad. Optimiza el efecto de filtración con los parámetros beta y alpha, y opcionalmente reduce la latencia.
- Ajuste de la anchura del canal: Ajuste dinámico de la anchura del canal basado en la amplitud de onda real (TR), usando 1.414 como el múltiplo por defecto.
- La señal de RSI aleatoria: combinación de 14 RSI de ciclo y un indicador aleatorio para generar una señal por encima de 80 o por debajo de 20
- Condiciones de ingreso: Se requiere que se cumplan simultáneamente las tres condiciones de la subida del canal de Gauss, la subida de la brecha de precios y la señal de activación de RSI aleatoria.
- La lógica de salida: cerrar la posición cuando el precio cae por encima de la vía de Gauss.
Ventajas estratégicas
- La fiabilidad de la señal: el mecanismo de confirmación de múltiples indicadores mejora significativamente la fiabilidad de la señal de negociación.
- Adaptabilidad: El canal de Gauss puede ajustar automáticamente la anchura del canal según las fluctuaciones del mercado.
- Filtración de ruido: Los filtros de Gauss reducen el impacto del ruido en el mercado.
- Alta flexibilidad: ofrece varios parámetros ajustables, incluidos el ciclo de la vía, el número de polos y el parámetro RSI.
- Intuitivo visual: muestra la dirección de la tendencia y las señales de negociación de forma intuitiva a través del cambio de color.
Riesgo estratégico
- Sensibilidad de los parámetros: el número de puntos y la configuración del ciclo de muestreo de Gauss influyen en el rendimiento de la estrategia.
- Riesgo de atraso: A pesar de las opciones que se ofrecen para reducir el atraso, el indicador en sí tiene un cierto atraso.
- Riesgo de falsas rupturas: Las señales falsas de ruptura pueden ser frecuentes en los mercados horizontales.
- Insuficiencia de la gestión de fondos: La versión actual carece de un mecanismo detallado de gestión de posiciones.
Dirección de optimización de la estrategia
- Identificación del entorno del mercado: agregar indicadores de la fuerza de la tendencia y ajustar los parámetros de la estrategia en diferentes entornos del mercado.
- Optimización de parámetros dinámicos: ajuste automático de la configuración de los parámetros del canal de Gauss según la volatilidad del mercado.
- Mejora en la gestión de posiciones: introducción de un sistema de gestión de posiciones dinámico basado en la volatilidad.
- Mejora del mecanismo de salida: aumento del movimiento de stop loss y del mecanismo de cierre parcial de ganancias.
- Optimización del marco de tiempo: validación de señales en varios marcos de tiempo para mejorar la estabilidad de las transacciones.
Resumir
La estrategia combina un filtro de Gauss y un indicador de RSI aleatorio para construir un sistema de negociación con una mayor capacidad de adaptación. La base matemática de Gauss garantiza la suavidad y la fiabilidad de la señal, mientras que la combinación de RSI aleatorio mejora aún más la precisión de la hora de entrada. La principal ventaja de la estrategia reside en su filtración efectiva del ruido del mercado y la captura precisa de las tendencias, pero también debe tener en cuenta la optimización numérica y la gestión del riesgo.
Código Fuente de la Estrategia
/*backtest
start: 2024-02-22 00:00:00
end: 2025-02-19 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"SOL_USDT"}]
*/
//@version=5
strategy(title="Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, slippage=0, fill_orders_on_standard_ohlc=true)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Filter Functions (Must be declared first)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
_f := math.pow(_a, _i) * nz(_s) + _i * _x * nz(_f[1]) - (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ? _m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ? _m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ? _m9 * math.pow(_x, 9) * nz(_f[9]) : 0)
f_pole(_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.0
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 : _i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 : _i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Calculations
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)
src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr
[filterMain, filter1] = f_pole(alpha, srcData, poles)
[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)
finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain
finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain
hband = finalFilter + finalTR * mult
lband = finalFilter - finalTR * mult
// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Trading Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20
longCondition = gaussianGreen and priceAbove and stochCondition
exitCondition = ta.crossunder(close, hband)
strategy.entry("Long", strategy.long, when=longCondition)
strategy.close("Long", when=exitCondition)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Visuals
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")