O recurso está a ser carregado... Carregamento...

Estratégia de Equilíbrio da Fenda do Leão

Autora:ChaoZhang, Data: 2023-11-02 16:55:00
Tags:

Resumo

A estratégia de equilíbrio da fenda do leão é uma estratégia de negociação de curto prazo simples baseada em cruzamento de médias móveis. Ele usa principalmente duas médias móveis - quando o MA rápido cruza acima do MA lento de baixo, vá longo; quando o MA rápido cruza abaixo do MA lento de cima, feche a posição.

Estratégia lógica

A estratégia usa duas médias móveis: uma MA rápida (smallMAPeriod) e uma MA lenta (bigMAPeriod). As duas MA formam um canal de preços, com a MA rápida como a base do canal e a MA lenta como o teto do canal. Quando o preço quebra acima da base do canal para cima, vá longo; quando o preço quebra o teto do canal para baixo, feche a posição.

Especificamente, a estratégia primeiro calcula o MA rápido (smallMA) e o MA lento (bigMA). Em seguida, calcula a linha de compra (buyMA), que é (100 - percentBelowToBuy)% do MA lento. Quando o MA rápido cruza acima da linha de compra para cima, vá longo; ao atingir 1% de lucro ou manter 7 barras sem lucro, feche a posição.

Em resumo, a estratégia visa capturar a Lion Fissure entre os MAs para lucros a curto prazo.

Análise das vantagens

A estratégia apresenta as seguintes vantagens:

O conceito é simples, fácil de compreender e de implementar, e os crossovers de dupla MA são a estratégia de indicador técnico mais básica.
Facil backtesting. A estratégia usa diretamente o backtester incorporado no TradingView sem implementação adicional.
O TradingView pode exibir diretamente sinais comerciais e dados estatísticos em gráficos.
Risco controlado: a estratégia define as condições de captação de lucro e stop loss para controlar efetivamente a perda por negociação.
A adaptação flexível permite aos utilizadores ajustar os parâmetros MA e outros indicadores para se adequarem aos diferentes produtos e estilos de negociação.

Análise de riscos

A estratégia apresenta igualmente os seguintes riscos:

As estratégias de MA dupla tendem a gerar sinais falsos durante as consolidações.
O uso de cruzes MA apenas ignora outros fatores, potencialmente resultando em má qualidade do sinal.
Optimização de parâmetros difícil. Encontrar a combinação MA ideal requer extensa computação.
Bias de backtest: estratégias simples de MA dupla geralmente apresentam melhor desempenho em backtests do que negociação ao vivo.
Dificuldade de realizar o stop loss: os níveis de stop loss fixos podem não se adaptar às condições de mercado em evolução.

Orientações de otimização

A estratégia pode ser melhorada pelos seguintes aspectos:

Adicionar outros filtros como volume e volatilidade para evitar sinais ineficazes durante as consolidações.
Incorporar o viés da tendência para evitar a negociação contra-tendência.
Usar aprendizagem de máquina para encontrar parâmetros ideais, como a otimização de parâmetros sequenciais ou algoritmos genéticos.
Melhorar as estratégias de stop loss, como trailing stop loss e stop loss adaptativo para maior flexibilidade.
Otimizar o calendário de entrada utilizando outros indicadores para identificar pontos de entrada de maior probabilidade.
Realizar pesquisas quantitativas e backtesting para melhorar a estabilidade dos conjuntos de parâmetros otimizados.
Desenvolver sistemas de negociação automatizados para otimizar e avaliar sistematicamente as combinações de parâmetros.

Conclusão

A estratégia do Balanço da Fissura do Leão é uma excelente estratégia de início para iniciantes. Aplica a lógica simples de cruzamento duplo de MA e define regras de captação de lucro e parada de perda para capturar oscilações de preços de curto prazo. A estratégia é fácil de entender e implementar e mostra bons resultados de backtest. No entanto, sofre de dificuldade de otimização e desempenho ao vivo questionável. Podemos melhorar a estratégia incorporando outros indicadores, otimizando parâmetros e desenvolvendo sistemas de negociação automatizados.

/*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 --- ///////////////

Mais.