Estrategia de equilibrio de la fisura del león

El autor:¿ Qué pasa?, Fecha: 2023-11-02 16:55:00
Las etiquetas:

Resumen general

La estrategia de balance de la fisura del león es una estrategia de trading simple a corto plazo basada en cruces de promedios móviles. Utiliza principalmente dos promedios móviles - cuando el MA rápido cruza por encima del MA lento desde abajo, vaya largo; cuando el MA rápido cruza por debajo del MA lento desde arriba, cierre la posición.

Estrategia lógica

La estrategia utiliza dos promedios móviles: un MA rápido (smallMAPeriod) y un MA lento (bigMAPeriod). Los dos MA forman un canal de precios, con el MA rápido como la base del canal y el MA lento como el techo del canal.

Específicamente, la estrategia primero calcula el MA rápido (smallMA) y el MA lento (bigMA). Luego calcula la línea de compra (buyMA), que es (100 - por cientoBelowToBuy)% del MA lento. Cuando el MA rápido cruza por encima de la línea de compra hacia arriba, vaya largo; al alcanzar el 1% de ganancia o mantener 7 barras sin ganancia, cierre la posición.

En resumen, la estrategia tiene como objetivo capturar la "Respina del León" entre las MAs para obtener ganancias a corto plazo.

Análisis de ventajas

La estrategia tiene las siguientes ventajas:

Concepto sencillo, fácil de entender e implementar.
La estrategia utiliza directamente el backtester incorporado de TradingView sin implementación adicional.
TradingView puede mostrar directamente señales comerciales y datos estadísticos en gráficos.
La estrategia establece las condiciones de obtención de ganancias y de detención de pérdidas para controlar efectivamente la pérdida por operación.
Personalización flexible: los usuarios pueden ajustar los parámetros de MA y otros indicadores para adaptarse a diferentes productos y estilos comerciales.

Análisis de riesgos

La estrategia también presenta los siguientes riesgos:

Las estrategias de doble MA tienden a generar señales falsas durante las consolidaciones.
La dependencia de un solo indicador: el uso de cruces MA ignora otros factores, lo que puede resultar en una mala calidad de la señal.
La búsqueda de la combinación óptima de MA requiere un extenso cálculo.
Las estrategias simples de doble MA a menudo tienen un mejor rendimiento en las pruebas de retroceso que el comercio en vivo.
Los niveles fijos de stop loss pueden no adaptarse a las condiciones cambiantes del mercado.

Direcciones de optimización

La estrategia puede mejorarse en los siguientes aspectos:

Añadir otros filtros como volumen y volatilidad para evitar señales ineficaces durante las consolidaciones.
Incorporar el sesgo de tendencia para evitar la negociación contra tendencia.
Utilice el aprendizaje automático para encontrar parámetros óptimos, como la optimización de parámetros secuenciales o algoritmos genéticos.
Mejorar las estrategias de stop loss, como el trailing stop loss y el stop loss adaptativo para una mejor flexibilidad.
Optimizar el tiempo de entrada utilizando otros indicadores para identificar puntos de entrada con mayor probabilidad.
Realizar investigaciones cuantitativas y pruebas de retroceso para mejorar la estabilidad de los conjuntos de parámetros optimizados.
Desarrollar sistemas de negociación automatizados para optimizar y evaluar sistemáticamente las combinaciones de parámetros.

Conclusión

La estrategia de equilibrio de la fisura del león es una excelente estrategia de inicio para los principiantes. Aplica la lógica simple de cruce de doble MA y establece reglas de toma de ganancias y de parada de pérdidas para capturar los cambios de precios a corto plazo. La estrategia es fácil de entender e implementar, y muestra buenos resultados de pruebas de retroceso. Sin embargo, sufre de dificultad de optimización y un rendimiento en vivo cuestionable. Podemos mejorar la estrategia incorporando otros indicadores, optimizando parámetros y desarrollando sistemas de negociación automatizados. En general, la estrategia de equilibrio de la fisura del león proporciona una gran plataforma de aprendizaje para los principiantes en negociación cuantitativa.

/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © TraderHalai
// This script was born out of my quest to be able to display strategy back test statistics on charts to allow for easier backtesting on devices that do not natively support backtest engine (such as mobile phones, when I am backtesting from away from my computer). There are already a few good ones on TradingView, but most / many are too complicated for my needs.
//
//Found an excellent display backtest engine by 'The Art of Trading'. This script is a snippet of his hard work, with some very minor tweaks and changes. Much respect to the original author.
//
//Full credit to the original author of this script. It can be found here: https://www.tradingview.com/script/t776tkZv-Hammers-Stars-Strategy/?offer_id=10&aff_id=15271
//
// This script can be copied and airlifted onto existing strategy scripts of your own, and integrates out of the box without implementation of additional functions. I've also added Max Runup, Average Win and Average Loss per trade to the orignal script.
//
//Will look to add in more performance metrics in future, as I further develop this script.
//
//Feel free to use this display panel in your scripts and strategies.

//Thanks and enjoy! :)
//@version=5
// strategy("Strategy BackTest Display Statistics - TraderHalai", overlay=true, default_qty_value= 5, default_qty_type = strategy.percent_of_equity, initial_capital=10000,  commission_type=strategy.commission.percent, commission_value=0.1)

//DEMO basic strategy - Use your own strategy here -  Jaws Mean Reversion from my profile used here
source = input(title = "Source", defval = close)
smallMAPeriod = input(title = "Small Moving Average", defval = 2)
bigMAPeriod = input(title = "Big Moving Average", defval = 8)
percentBelowToBuy = input(title = "Percent below to buy %", defval = 1)

smallMA = ta.sma(source, smallMAPeriod)
bigMA =  ta.sma(source, bigMAPeriod) 
buyMA = ((100 - percentBelowToBuy) / 100) * ta.sma(source, bigMAPeriod)[0]

buy = ta.crossunder(smallMA, buyMA)
if(buy)
    strategy.entry("BUY", strategy.long)

if(strategy.openprofit >= strategy.position_avg_price * 0.01) // 1% profit target
    strategy.close("BUY")

if(ta.barssince(buy) >= 7) //Timed Exit, if you fail to make 1 percent in 7 candles.
    strategy.close("BUY")
    
///////////////////////////// --- BEGIN TESTER CODE --- ////////////////////////
// COPY below into your strategy to enable display
////////////////////////////////////////////////////////////////////////////////

// strategy.initial_capital = 50000
// // Declare performance tracking variables
// drawTester = input.bool(true, "Draw Tester")
// var balance = strategy.initial_capital
// var drawdown = 0.0
// var maxDrawdown = 0.0
// var maxBalance = 0.0
// var totalWins = 0
// var totalLoss = 0

// // Prepare stats table
// var table testTable = table.new(position.top_right, 5, 2, border_width=1)
// f_fillCell(_table, _column, _row, _title, _value, _bgcolor, _txtcolor) =>
//     _cellText = _title + "\n" + _value
//     table.cell(_table, _column, _row, _cellText, bgcolor=_bgcolor, text_color=_txtcolor)
    
// // Custom function to truncate (cut) excess decimal places
// truncate(_number, _decimalPlaces) =>
//     _factor = math.pow(10, _decimalPlaces)
//     int(_number * _factor) / _factor
    
// // Draw stats table
// var bgcolor = color.new(color.black,0)
// if drawTester
//     if barstate.islastconfirmedhistory
//         // Update table
//         dollarReturn = strategy.netprofit
//         f_fillCell(testTable, 0, 0, "Total Trades:", str.tostring(strategy.closedtrades), bgcolor, color.white)
//         f_fillCell(testTable, 0, 1, "Win Rate:", str.tostring(truncate((strategy.wintrades/strategy.closedtrades)*100,2)) + "%", bgcolor, color.white)
//         f_fillCell(testTable, 1, 0, "Starting:", "$" + str.tostring(strategy.initial_capital), bgcolor, color.white)
//         f_fillCell(testTable, 1, 1, "Ending:", "$" + str.tostring(truncate(strategy.initial_capital + strategy.netprofit,2)), bgcolor, color.white)
//         f_fillCell(testTable, 2, 0, "Avg Win:", "$"+ str.tostring(truncate(strategy.grossprofit / strategy.wintrades, 2)), bgcolor, color.white)
//         f_fillCell(testTable, 2, 1, "Avg Loss:", "$"+ str.tostring(truncate(strategy.grossloss / strategy.losstrades, 2)), bgcolor, color.white)
//         f_fillCell(testTable, 3, 0, "Profit Factor:", str.tostring(truncate(strategy.grossprofit / strategy.grossloss,2)), strategy.grossprofit > strategy.grossloss ? color.green : color.red, color.white)
//         f_fillCell(testTable, 3, 1, "Max Runup:",  str.tostring(truncate(strategy.max_runup, 2 )), bgcolor, color.white)
//         f_fillCell(testTable, 4, 0, "Return:", (dollarReturn > 0 ? "+" : "") + str.tostring(truncate((dollarReturn / strategy.initial_capital)*100,2)) + "%", dollarReturn > 0 ? color.green : color.red, color.white)
//         f_fillCell(testTable, 4, 1, "Max DD:", str.tostring(truncate((strategy.max_drawdown / strategy.equity) * 100 ,2)) + "%", color.red, color.white)
// // --- END TESTER CODE --- ///////////////

Más.