Estrategia de trading cuantitativo optimizada por fluctuación de precios diferencial de redes neuronales

ATR ANN TANH OHLC4 volatility TIMEFRAME NEURAL NETWORK MACHINE LEARNING
Fecha de creación: 2025-06-23 11:39:44 Última modificación: 2025-06-23 11:39:44
Copiar: 5 Número de Visitas: 306
2
Seguir
319
Seguidores

Estrategia de trading cuantitativo optimizada por fluctuación de precios diferencial de redes neuronales Estrategia de trading cuantitativo optimizada por fluctuación de precios diferencial de redes neuronales

Descripción general

La estrategia de comercio cuantitativa de optimización de fluctuaciones de precios de la red neuronal diferencial es un sistema de comercio de alta frecuencia basado en la red neuronal artificial (ANN) diseñado para optimizar el marco de tiempo a nivel de 1 segundo. La estrategia utiliza la red neuronal para analizar las diferencias de cambio de precios a corto plazo, predecir la dirección de los precios mediante algoritmos de transmisión hacia adelante y, en combinación con la filtración de la tasa de fluctuación y el control de la hora de la sesión, optimizar las decisiones de comercio.

Principio de estrategia

La estrategia utiliza una arquitectura de red neuronal de tres capas para procesar los datos de diferencia de precios a través de algoritmos de transmisión hacia adelante:

  1. La capa de entrada (L0): La diferencia porcentual entre la recepción de la OHLC4 actual (< promedio de apertura y caída) y el marco de tiempo de referencia (< 15 segundos por defecto) de la OHLC4 histórica como una sola neurona de entrada.

  2. Primera capa oculta (L1): Contiene 5 neuronas que utilizan la función de activación tanh para realizar una transformación no lineal de los datos de entrada. Cada neurona tiene un peso previamente entrenado para capturar un patrón específico de diferencia de precios.

  3. Segunda capa oculta (L2): Contiene 33 neuronas, que también utilizan la función de activación tanh para procesar aún más la salida de la primera capa oculta a través de una matriz de pesos más compleja.

  4. Capa de salida: Una neurona produce una señal final de predicción cuyo valor se invierte para corregir la dirección de la señal.

La lógica de transacción se desarrolla en torno a los valores de salida de la red neuronal ((L3_0)):

  • Cuando L3_0 es mayor que el umbral de entrada (el 0.003 por defecto), se activa la señal de multitarea
  • Cuando L3_0 es menor que el umbral de entrada negativo ((-0.003), se dispara la señal de vacío
  • Cuando L3_0 es menor que el umbral de salida (el 0.001 por defecto), se cancela la posición
  • Cuando L3_0 es mayor que el umbral de salida negativo (−0.001), la posición está vacía

La estrategia también tiene un triple mecanismo de filtrado:

  • Filtrado por tiempo de refrigeración: Después de ejecutar la transacción, el sistema obliga a esperar el período de enfriamiento indicado (de 60 segundos por defecto)
  • Filtro de fluctuacionesA través del indicador ATR (Average True Range), solo se negocian cuando la volatilidad del mercado supera el umbral mínimo (el 0.02 por defecto)
  • Filtrado por período de transacción: selectivamente restringir las operaciones a una hora específica del mercado (default: 9:00 a 16:00)

Ventajas estratégicas

  1. Capacidad de predicción de alta precisión: La estructura multicamilla de la red neuronal es capaz de capturar relaciones complejas no lineales en el movimiento de los precios, lo que es difícil de lograr con los indicadores técnicos tradicionales. Especialmente en entornos de alta frecuencia, la estructura puede reconocer patrones de precios a corto plazo y proporcionar señales de entrada y salida más precisas.

  2. Excelente relación entre el riesgo y el beneficio: La estrategia alcanzó un factor de ganancia de 3.754, lo que significa que el total de las operaciones ganadoras es 3.754 veces el total de las operaciones perdedoras, lo que es un rendimiento muy bueno en una estrategia cuantificada.

  3. Espacio de optimización de parámetros flexibleLa estrategia ofrece una variedad de parámetros ajustables, incluidos los mínimos de entrada/salida, la duración del período de enfriamiento, el marco de tiempo de referencia y los requisitos de fluctuación mínima, lo que permite a los operadores optimizar en función de diferentes entornos de mercado y variedades de operaciones.

  4. Mecanismo de filtración múltipleA través de la integración de la triple filtración de los períodos de enfriamiento, la volatilidad y el tiempo de negociación, la estrategia reduce de manera efectiva las transacciones innecesarias y las falsas señales, mejorando la calidad de las transacciones.

  5. Adaptación al entorno de las altas frecuenciasOptimizado para el marco de tiempo de 1 segundo, permite aprovechar las características de las operaciones de alta frecuencia para capturar oportunidades de ganancias derivadas de las fluctuaciones de precios a corto plazo.

  6. Implementación de baja latenciaLa estructura del código de la estrategia es clara y eficiente, la parte de la red neuronal utiliza pesos de entrenamiento previo para el cálculo directo, sin necesidad de entrenamiento en tiempo real, para garantizar una ejecución de baja latencia en entornos de alta frecuencia.

Riesgo estratégico

  1. El riesgo de exceso de adaptaciónEl modelo de la red neuronal contiene una gran cantidad de parámetros de peso predeterminados, con el riesgo de que los datos históricos sean excesivamente ajustados. Esto puede hacer que la estrategia no se muestre tan bien en las operaciones reales, especialmente cuando las condiciones del mercado cambian significativamente. Los métodos de respuesta incluyen: reentrenamiento periódico de la red neuronal, verificación con datos de períodos de tiempo más largos, y la implementación de sólidas medidas de gestión de riesgos.

  2. Sensibilidad de los parámetros: El rendimiento de la estrategia depende en gran medida de la configuración de varios parámetros, como el umbral de entrada / salida, la duración del período de enfriamiento, etc. Las pequeñas variaciones en los parámetros pueden causar una gran fluctuación en el rendimiento de la estrategia. Se recomienda encontrar una combinación de parámetros estable a través de la exploración de parámetros y la prueba de paso, y evitar la optimización excesiva.

  3. Riesgo de las operaciones de alta frecuenciaEn un marco de tiempo de 1 segundo, los costos de transacción (como los puntos de diferencia y los puntos de deslizamiento) pueden afectar significativamente la rentabilidad de la estrategia. Estos costos deben ser considerados antes de la negociación en vivo y se deben simular las condiciones reales de costos de transacción en la retroalimentación.

  4. Desafíos de la tecnología: Las estrategias de alta frecuencia requieren que los sistemas de negociación tengan una latencia extremadamente baja y una alta fiabilidad. Cualquier retraso en la red, retraso en los datos o retraso en la ejecución puede causar la falla de la estrategia. Asegúrese de usar una infraestructura de negociación de nivel profesional y fuentes de datos de baja latencia.

  5. Riesgo de fluctuaciones en el mercadoEn condiciones extremas de mercado (por ejemplo, noticias repentinas o agotamiento de la liquidez), los modelos de redes neuronales pueden no predecir con precisión los movimientos de los precios, lo que provoca grandes pérdidas. Se recomienda establecer medidas de parada de pérdidas y límites de pérdidas máximas diarias, y suspender el funcionamiento de la estrategia durante las fluctuaciones extremas.

Dirección de optimización de la estrategia

  1. Optimización de la arquitectura de las redes neuronales:

    • Considerar la introducción de más características de entrada, como volumen de operaciones, indicadores de volatilidad y indicadores de movimiento de precios, para mejorar la capacidad de predicción del modelo
    • Experimentar con diferentes estructuras de capas ocultas y número de neuronas para encontrar el equilibrio óptimo entre complejidad y capacidad de generalización
    • Explorar el efecto de otras funciones de activación (como ReLU o Leaky ReLU) que superan a tanh en algunas aplicaciones de redes neuronales
  2. Mecanismo de ajuste de parámetros dinámicos:

    • Hacer que los umbrales de entrada/salida se ajusten de forma adaptativa en función de las condiciones del mercado, por ejemplo, aumentando los umbrales en un entorno de alta volatilidad y reduciendo los umbrales en un entorno de baja volatilidad
    • Desarrollo de algoritmos de ajuste de período de enfriamiento para la percepción de la volatilidad, lo que permite a las estrategias mantener una frecuencia de negociación óptima en diferentes fases del mercado
  3. Marco de predicción integrado:

    • Modelos de redes neuronales combinados en varios marcos de tiempo para formar una señal de predicción integrada
    • Introducción de un metamodelo de aprendizaje automático para ajustar dinámicamente el peso de los diferentes modelos de predicción
    • Este método reduce las limitaciones de un solo modelo y mejora la estabilidad de las predicciones.
  4. Mejora de la gestión de riesgos:

    • Desarrollo de un sistema de gestión de posiciones dinámicas que ajuste el tamaño de las transacciones según la confianza del modelo y las condiciones del mercado
    • Introducción de estrategias de stop loss basadas en el aprendizaje automático para optimizar el riesgo-rendimiento por transacción
    • Optimización de horarios para identificar las estrategias que funcionan mejor durante el día
  5. Aprendizaje y adaptación en tiempo real:

    • Diseño de mecanismos de aprendizaje en línea para que las redes neuronales puedan aprender continuamente de nuevos datos y adaptarse a los cambios en el mercado
    • Implementa un disparador de reentrenamiento automático basado en la supervisión del rendimiento, actualizando activamente el modelo cuando el rendimiento de la estrategia disminuye
    • Este método puede mejorar significativamente la vida útil y la estabilidad de las estrategias.

Resumir

La estrategia de comercio cuantitativo de optimización de las fluctuaciones de precios de las redes neuronales representa una práctica vanguardista en el comercio cuantitativo moderno, que aplica con éxito la tecnología de redes neuronales artificiales en el campo de la negociación de alta frecuencia. A través de una estructura de redes neuronales de múltiples capas cuidadosamente diseñada, la estrategia puede capturar patrones sutiles en los cambios de precios a corto plazo y mejorar la calidad de las transacciones mediante múltiples mecanismos de filtrado.

El factor de ganancias de 3.754 demuestra que la estrategia ha funcionado bien en un entorno de prueba, pero la aplicación práctica aún debe tener en cuenta cuidadosamente los riesgos inherentes a la sobreadaptación, la sensibilidad de los parámetros y la negociación de alta frecuencia. La estrategia tiene el potencial de mantenerse competitiva a largo plazo en el sector de las operaciones cuantitativas altamente competitivas mediante la optimización continua de la arquitectura de la red neuronal, la implementación de ajustes de parámetros dinámicos y la mejora de la gestión del riesgo.

El factor clave de éxito de la estrategia reside en la combinación de una tecnología de red neuronal compleja con una lógica de negociación práctica, que aprovecha la capacidad de predicción del aprendizaje automático y tiene en cuenta la viabilidad de las operaciones reales. Para los comerciantes de cuantificación experimentados, esto ofrece un marco escalable que se puede personalizar y optimizar aún más según los diferentes mercados y las preferencias de riesgo personales.

Código Fuente de la Estrategia
/*backtest
start: 2024-06-23 00:00:00
end: 2025-06-21 08:00:00
period: 2h
basePeriod: 2h
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

//@version=5
strategy("ANN Strategy v2 (Optimized for 1s)", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// === INPUTS ===
entryThreshold = input.float(0.003, title="Entry Threshold")
exitThreshold  = input.float(0.001, title="Exit Threshold")
cooldownBars   = input.int(60, title="Cooldown (bars)")  // 60 seconds cooldown
timeframe      = input.timeframe("1", title="Reference Timeframe")  // 1-minute diff reference
minVolatility  = input.float(0.02, title="Min ATR (Volatility Filter)")
useSession     = input.bool(true, title="Use Session Filter")

// === UTILITY FUNCTIONS ===
getDiff() =>
    prev = request.security(syminfo.tickerid, timeframe, ohlc4[1])
    now = ohlc4
    (now - prev) / prev

linear(v) => v
tanh(v) => (math.exp(v) - math.exp(-v)) / (math.exp(v) + math.exp(-v))

// === ANN FORWARD PROPAGATION ===
l0_0 = linear(getDiff())

l1 = array.new_float()
array.push(l1, tanh(l0_0 * 0.8446488687))
array.push(l1, tanh(l0_0 * -0.5674069006))
array.push(l1, tanh(l0_0 * 0.8676766445))
array.push(l1, tanh(l0_0 * 0.5200611473))
array.push(l1, tanh(l0_0 * -0.2215499554))

// === Layer 2 weights ===
w2 = array.from(    0.3341657935, -2.0060003664, 0.8606354375, 0.9184846912, -0.8531172267,    -0.0394076437, -0.4720374911, 0.2900968524, 1.0653326022, 0.3000188806,    -0.559307785, -0.9353655177, 1.2133832962, 0.1952686024, 0.8552068166,    -0.4293220754, 0.8484259409, -0.7154087313, 0.1102971055, 0.2279392724,    0.9111779155, 0.2801691115, 0.0039982713, -0.5648257117, 0.3281705155,    -0.2963954503, 0.4046532178, 0.2460580977, 0.6608675819, -0.8732022547,    0.8810811932, 0.6903706878, -0.5953059103, -0.3084040686, -0.4038498853,    -0.5687101164, 0.2736758588, -0.2217360382, 0.8742950972, 0.2997583987,    0.0708459913, 0.8221730616, -0.7213265567, -0.3810462836, 0.0503867753,    0.4880140595, 0.9466627196, 1.0163097961, -0.9500386514, -0.6341709382,    1.3402207103, 0.0013395288, 3.4813009133, -0.8636814677, 41.3171047132,    1.2388217292, -0.6520886912, 0.3508321737, 0.6640560714, 1.5936220597,    -0.1800525171, -0.2620989752, 0.056675277, -0.5045395315, 0.2732553554,    -0.7776331454, 0.1895231137, 0.5384918862, 0.093711904, -0.3725627758,    -0.3181583022, 0.2467979854, 0.4341718676, -0.7277619935, 0.1799381758,    -0.5558227731, 0.3666152536, 0.1538243225, -0.8915928174, -0.7659355684,    0.6111516061, -0.5459495224, -0.5724238425, -0.8553500765, -0.8696190472,    0.6843667454, 0.408652181, -0.8830470112, -0.8602324935, 0.1135462621,    -0.1569048216, -1.4643247888, 0.5557152813, 1.0482791924, 1.4523116833,    0.5207514017, -0.2734444192, -0.3328660936, -0.7941515963, -0.3536051491,    -0.4097807954, 0.3198619826, 0.461681627, -0.1135575498, 0.7103339851,    -0.8725014237, -1.0312091401, 0.2267643037, -0.6814258121, 0.7524828703,    -0.3986855003, 0.4962556631, -0.7330224516, 0.7355772164, 0.3180141739,    -1.083080442, 1.8752543187, 0.3623326265, -0.348145191, 0.1977935038,    -0.0291290625, 0.0612906199, 0.1219696687, -1.0273685429, 0.0872219768,    0.931791094, -0.313753684, -0.3028724837, 0.7387076712, 0.3806140391,    0.2630619402, -1.9827996702, -0.7741413496, 0.1262957444, 0.2248777886,    -0.2666322362, -1.124654664, 0.7288282621, -0.1384289204, 0.2395966188,    0.6611845175, 0.0466048937, -0.1980999993, 0.8152350927, 0.0032723211,    -0.3150344751, 0.1391754608, 0.5462816249, -0.7952302364, -0.7520712378,    -0.0576916066, 0.3678415302, 0.6802537378, 1.1437036331, -0.8637405666,    0.7016273068, 0.3978601709, 0.3157049654, -0.2528455662, -0.8614146703,    1.1741126834, -1.4046408959, 1.2914477803, 0.9904052964, -0.6980155826)


l2 = array.new_float()
for i = 0 to 32
    sum = 0.0
    for j = 0 to 4
        weight = array.get(w2, i * 5 + j)
        sum += weight * array.get(l1, j)
    array.push(l2, tanh(sum))

// === Output layer weights ===
weights_out = array.from(    -0.1366382003, 0.8161960822, -0.9458773183, 0.4692969576, 0.0126710629,    -0.0403001012, -0.0116244898, -0.4874816289, -0.6392241448, -0.410338398,    -0.1181027081, 0.1075562037, -0.5948728252, 0.5593677345, -0.3642935247,    -0.2867603217, 0.142250271, -0.0535698019, -0.034007685, -0.3594532426,    0.2551095195, 0.4214344983, 0.8941621336, 0.6283377368, -0.7138020667,    -0.1426738249, 0.172671223, 0.0714824385, -0.3268182144, -0.0078989755,    -0.2032828145, -0.0260631534, 0.4918037012)


sum_out = 0.0
for i = 0 to array.size(l2) - 1
    sum_out += array.get(weights_out, i) * array.get(l2, i)

// === Final ANN output (inverted for signal correction) ===
l3_0 = -tanh(sum_out)

// === TRADE FILTERS ===
volatility = ta.atr(14)
isVolOkay = volatility > minVolatility

isSession = (hour >= 9 and hour < 16)  // Adjust to your market hours
sessionOkay = useSession ? isSession : true

// === SIGNAL LOGIC ===
var string activeTrade = "none"
var int lastTradeBar = na
canTrade = (na(lastTradeBar) or (bar_index - lastTradeBar > cooldownBars)) and isVolOkay and sessionOkay

enterLong  = l3_0 > entryThreshold  and activeTrade != "long"  and canTrade
exitLong   = l3_0 < exitThreshold   and activeTrade == "long"
enterShort = l3_0 < -entryThreshold and activeTrade != "short" and canTrade
exitShort  = l3_0 > -exitThreshold  and activeTrade == "short"

// === STRATEGY EXECUTION ===
if barstate.isrealtime
    if enterLong
        strategy.entry("Long", strategy.short)
        activeTrade := "long"
        lastTradeBar := bar_index

    if exitLong
        strategy.close("Long")
        activeTrade := "none"

    if enterShort
        strategy.entry("Short", strategy.long)
        activeTrade := "short"
        lastTradeBar := bar_index

    if exitShort
        strategy.close("Short")
        activeTrade := "none"

// === PLOTTING ===
bgcolor(activeTrade == "long" ? color.new(color.green, 85) : activeTrade == "short" ? color.new(color.red, 85) : na)
plot(l3_0, title="ANN Output (Inverted)", color=color.aqua, linewidth=2)