En la carga de los recursos... Cargando...

Estrategia de negociación de puntuación por múltiples indicadores

El autor:¿ Qué pasa?, Fecha: 2023-11-07 16:16:45
Las etiquetas:

Resumen general

La estrategia de negociación de puntuación de múltiples indicadores integra puntuación de indicadores técnicos para identificar la dirección de la tendencia y la fuerza para la negociación automatizada. Considera un grupo de indicadores que incluyen Ichimoku Cloud, HMA, RSI, Stoch, CCI y MACD. Cada resultado del indicador se puntua y la puntuación general se calcula promediando todos los indicadores. Cuando la puntuación general está por encima del umbral, vaya largo. Cuando está por debajo del umbral, vaya corto.

Estrategia lógica

La estrategia consta de varias partes:

Calcular un grupo de indicadores que incluyen la nube de Ichimoku, la media móvil del casco, el índice de fuerza relativa, el estocástico, el índice del canal de productos básicos y la divergencia de convergencia de la media móvil.
Da una puntuación positiva para la señal alcista y una puntuación negativa para la señal bajista.
Suma y promedio de todos los indicadores para obtener una puntuación general.
Compare la puntuación general con el umbral preestablecido para determinar la dirección general de la tendencia.
Posición abierta basada en el juicio, larga cuando es alcista, corta cuando es bajista.
Establecer el stop loss y tomar ganancias basado en ATR.

La estrategia aprovecha al máximo las ventajas de múltiples indicadores para determinar la tendencia del mercado.

Análisis de ventajas

Las ventajas de esta estrategia incluyen:

La combinación de múltiples indicadores mejora la precisión de la señal. El indicador único es propenso a señales falsas.
Utilice los puntos fuertes de los indicadores para identificar tendencia e impulso. Por ejemplo, Ichimoku Cloud para tendencia, Stochastics para sobrecompra y sobreventa.
El comercio automatizado evita impactos emocionales y sigue estrictamente las señales de estrategia.
El uso de ATR para detener pérdidas y obtener ganancias ayuda a la gestión de riesgos.
Los parámetros y el umbral de puntuación se pueden optimizar para diferentes productos.
Lógica simple y clara, fácil de entender y modificar.

Análisis de riesgos

Los riesgos de esta estrategia:

La combinación de múltiples indicadores no es necesariamente mejor que una sola, se necesitan pruebas repetitivas para encontrar parámetros óptimos.
Los puntajes promedio no pueden evitar completamente las pérdidas cuando los indicadores dan señales erróneas.
Las paradas de ATR pueden estar demasiado cerca o demasiado sueltas.
Evite el sobreajuste por optimizaciones excesivas. Pruebe la robustez en diferentes productos y períodos de tiempo.
La alta frecuencia de negociación aumenta los costes de transacción que también afectan al rendimiento final.

Direcciones de optimización

La estrategia se puede optimizar en los siguientes aspectos:

Prueba más combinaciones de indicadores para encontrar la selección óptima para un producto específico.
Ajustar los índices de puntuación, optimizar el algoritmo de puntuación.
Parámetros ATR dinámicos para adaptarse mejor a la volatilidad del mercado.
Añadir filtros de operaciones para reducir la frecuencia de operaciones innecesaria, como el filtro de tendencia o el filtro de volumen.
Optimiza paso a paso para encontrar el rango de parámetros, luego optimiza aleatoriamente / en red para obtener el mejor conjunto de parámetros.
Prueba de robustez en varios productos y plazos para evitar el sobreajuste.
Combinar con otras estrategias comerciales efectivas para cartera.

Conclusión

La estrategia de puntuación de múltiples indicadores mejora la precisión y confiabilidad de la señal a través de la media de puntuaciones de indicadores. Con un gran espacio de optimización, se puede optimizar para buenos resultados en diferentes productos. Los riesgos de sobreajuste necesitan atención para mantener la optimización de parámetros y la prueba de estrategias científicas. Como idea de estrategia con amplias direcciones de optimización, merece más investigación y aplicación.

/*backtest
start: 2022-10-31 00:00:00
end: 2023-11-06 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy(title="Ichi HMA RSI Stoch CCI MACD Technicals Rating Strategy",shorttitle="TRSv420",overlay=true,default_qty_type=strategy.percent_of_equity,default_qty_value=50,commission_type=strategy.commission.percent,commission_value=0.05)
res = input("", title="Indicator Timeframe", type=input.resolution)
Period = input(defval = 14, title = "Period Length", minval = 2)
MinSignalStrength= input(title="Minimum Signal Strength", type=input.float, defval=1.1, minval=0.00, maxval=2.00, step=0.1)
Price = input(defval=open, title="Price Source", type=input.source)
Use_Only_Buy= input(false, title = "Use ONLY BUY mode",type=input.bool)
Use_Only_Sell= input(false, title = "Use ONLY SELL mode",type=input.bool)
Use_ATR_SL_TP= input(true, title = "Use ATR for TP & SL",type=input.bool)
Use_Ichimoku= input(true, title = "Use Ichimoku",type=input.bool)
Use_HMA= input(true, title = "Use Hull MA",type=input.bool)
Use_RSI= input(true, title = "Use RSI",type=input.bool)
Use_Stoch= input(true, title = "Use Stoch",type=input.bool)
Use_CCI= input(true, title = "Use CCI",type=input.bool)
Use_MACD= input(true, title = "Use MacD",type=input.bool)
// Ichimoku Cloud
donchian(len) => avg(lowest(len), highest(len))
ichimoku_cloud() =>
    conversionLine = donchian(9)
    baseLine = donchian(26)
    leadLine1 = avg(conversionLine, baseLine)
    leadLine2 = donchian(52)
    [conversionLine, baseLine, leadLine1, leadLine2]
[IC_CLine, IC_BLine, IC_Lead1, IC_Lead2] = ichimoku_cloud()    
calcRatingMA(ma, src) => na(ma) or na(src) ? na : (ma == src ? 0 : ( ma < src ? 1 : -1 ))
calcRating(buy, sell) => buy ? 1 : ( sell ? -1 : 0 )
calcRatingAll() =>
    //============== HMA =================
    HMA10 = hma(Price, Period)
    HMA20 = hma(Price, 20)
    HMA30 = hma(Price, 30)
    HMA50 = hma(Price, 50)
    HMA100 = hma(Price, 100)
    HMA200 = hma(Price, 200)
    // Relative Strength Index, RSI
    RSI = rsi(Price,14)
    // Stochastic
    lengthStoch = 14
    smoothKStoch = 3
    smoothDStoch = 3
    kStoch = sma(stoch(Price, high, low, lengthStoch), smoothKStoch)
    dStoch = sma(kStoch, smoothDStoch)
    // Commodity Channel Index, CCI
    CCI = cci(Price, 20)
    // Moving Average Convergence/Divergence, MACD
    [macdMACD, signalMACD, _] = macd(Price, 12, 26, 9)
    // -------------------------------------------
    PriceAvg = hma(Price, Period)
    DownTrend = Price < PriceAvg
    UpTrend = Price > PriceAvg
    float ratingMA = 0
    float ratingMAC = 0
    if(Use_HMA)
        if not na(HMA10)
            ratingMA := ratingMA + calcRatingMA(HMA10, Price)
            ratingMAC := ratingMAC + 1
        if not na(HMA20)
            ratingMA := ratingMA + calcRatingMA(HMA20, Price)
            ratingMAC := ratingMAC + 1
        if not na(HMA30)
            ratingMA := ratingMA + calcRatingMA(HMA30, Price)
            ratingMAC := ratingMAC + 1
        if not na(HMA50)
            ratingMA := ratingMA + calcRatingMA(HMA50, Price)
            ratingMAC := ratingMAC + 1
        if not na(HMA100)
            ratingMA := ratingMA + calcRatingMA(HMA100, Price)
            ratingMAC := ratingMAC + 1
        if not na(HMA200)
            ratingMA := ratingMA + calcRatingMA(HMA200, Price)
            ratingMAC := ratingMAC + 1
    if(Use_Ichimoku)
        float ratingIC = na
        if not (na(IC_Lead1) or na(IC_Lead2) or na(Price) or na(Price[1]) or na(IC_BLine) or na(IC_CLine))
            ratingIC := calcRating(
             IC_Lead1 > IC_Lead2 and Price > IC_Lead1 and Price < IC_BLine and Price[1] < IC_CLine and Price > IC_CLine,
             IC_Lead2 > IC_Lead1 and Price < IC_Lead2 and Price > IC_BLine and Price[1] > IC_CLine and Price < IC_CLine)
        if not na(ratingIC)
            ratingMA := ratingMA + ratingIC
            ratingMAC := ratingMAC + 1
    ratingMA := ratingMAC > 0 ? ratingMA / ratingMAC : na
    float ratingOther = 0
    float ratingOtherC = 0
    if(Use_RSI)
        ratingRSI = RSI
        if not(na(ratingRSI) or na(ratingRSI[1]))
            ratingOtherC := ratingOtherC + 1
            ratingOther := ratingOther + calcRating(ratingRSI < 30 and ratingRSI[1] < ratingRSI, ratingRSI > 70 and ratingRSI[1] > ratingRSI)
    if(Use_Stoch)
        if not(na(kStoch) or na(dStoch) or na(kStoch[1]) or na(dStoch[1]))
            ratingOtherC := ratingOtherC + 1
            ratingOther := ratingOther + calcRating(kStoch < 20 and dStoch < 20 and kStoch > dStoch and kStoch[1] < dStoch[1], kStoch > 80 and dStoch > 80 and kStoch < dStoch and kStoch[1] > dStoch[1])
    if(Use_CCI)
        ratingCCI = CCI
        if not(na(ratingCCI) or na(ratingCCI[1]))
            ratingOtherC := ratingOtherC + 1
            ratingOther := ratingOther + calcRating(ratingCCI < -100 and ratingCCI > ratingCCI[1], ratingCCI > 100 and ratingCCI < ratingCCI[1])
    if(Use_MACD)
        if not(na(macdMACD) or na(signalMACD))
            ratingOtherC := ratingOtherC + 1
            ratingOther := ratingOther + calcRating(macdMACD > signalMACD, macdMACD < signalMACD)
    ratingOther := ratingOtherC > 0 ? ratingOther / ratingOtherC : na
    float ratingTotal = 0
    float ratingTotalC = 0
    if not na(ratingMA)
        ratingTotal := ratingTotal + ratingMA
        ratingTotalC := ratingTotalC + 1
        ratingTotal := ratingTotal + ratingOther
        ratingTotalC := ratingTotalC + 1
    ratingTotal := ratingTotalC > 0 ? ratingTotal / ratingTotalC : na
    [ratingTotal, ratingOther, ratingMA, ratingOtherC, ratingMAC]
[ratingTotal, ratingOther, ratingMA, ratingOtherC, ratingMAC]  = security(syminfo.tickerid, res, calcRatingAll(), lookahead=false)
tradeSignal = ratingTotal+ratingOther+ratingMA
dynSLpoints(factor) => factor * atr(14) / syminfo.mintick
if not (Use_Only_Sell)
    strategy.entry("long", strategy.long, when = tradeSignal > MinSignalStrength)
if not (Use_Only_Buy)    
    strategy.entry("short", strategy.short, when = tradeSignal < -MinSignalStrength)
if(Use_ATR_SL_TP)
    strategy.exit("sl/tp", loss = dynSLpoints(3), trail_points = dynSLpoints(5), trail_offset = dynSLpoints(2))

Más.