Estrategia de seguimiento de tendencias dinámicas
ChaoZhang
Descripción general
La idea principal de esta estrategia es el seguimiento dinámico de la tendencia del mercado, comprando cuando la tendencia es al alza y vendiendo cuando la tendencia es a la baja. Se determina la dirección de la tendencia mediante el cálculo de una combinación de varios indicadores, como la regresión lineal, la media móvil modificada de Hull, etc.
Principio de estrategia
Esta estrategia utiliza varios indicadores técnicos para determinar la dirección de la tendencia. En primer lugar, se calcula un canal de rango, cuyo límite superior y inferior se calcula a partir de una media móvil simple de close y un parámetro de entrada. Luego, se calcula una media móvil modificada de Hull, que se considera una descripción más precisa de la tendencia. Además, se calcula un indicador de regresión lineal.
Para reducir las señales erróneas, la estrategia también diseñó varios filtros. Por ejemplo, el uso de EMA para determinar si está en una tendencia descendente y el uso de un indicador de ventana para determinar el cambio en el RSI. Estos filtros evitan la generación de señales de negociación en situaciones de crisis.
En cuanto a la entrada y la parada, la estrategia registra el último precio de apertura de la posición y establece un porcentaje de stop-loss. Por ejemplo, si el precio de apertura de la última posición es de \( 100, se establece un objetivo de stop-loss de \) 102 y un precio de parada de $ 95. Así se logra el seguimiento dinámico.
Análisis de las ventajas
Esta estrategia tiene las siguientes ventajas:
- El sistema de seguimiento dinámico de los cambios de tendencia permite capturar fácilmente la dirección de las líneas más largas.
- El uso de varios filtros reduce el ruido y evita el uso frecuente de transacciones en situaciones convulsivas.
- Ajuste automático de la posición de la parada de pérdidas para lograr el seguimiento de la tendencia.
- Se puede encontrar automáticamente la combinación óptima de parámetros mediante optimización de parámetros.
Análisis de riesgos
La estrategia también tiene sus riesgos:
- El riesgo de ser manipulado por el mercado aún no se puede evitar por completo.
- La configuración incorrecta de los parámetros puede causar un mal rendimiento de la estrategia. Se necesita optimizar para encontrar la combinación óptima de parámetros.
- El exceso de tiempo de procesamiento de datos puede causar un retraso en la señal. Se necesita optimizar el cálculo de los indicadores para que sea lo más realista posible.
Para controlar el riesgo, puede establecer un stop loss, trail stop o usar opciones para bloquear los beneficios. Además, se debe probar repetidamente la combinación de parámetros para encontrar un rango de parámetros confiable. Finalmente, también se debe prestar atención al tiempo de cálculo del indicador y buscar la actualidad de la señal.
Dirección de optimización
La estrategia puede ser optimizada en los siguientes aspectos:
- En la actualidad, la mayoría de los países de la Unión Europea (UE) tienen un sistema de medición basado en el índice de inflación, el índice de desempleo y el índice de desempleo.
- Ajustar el rango de los parámetros para encontrar el mejor;
- Optimizar los filtros de señal para encontrar el equilibrio entre el ruido y el retraso.
- Intentar generar automáticamente las reglas de las transacciones con métodos como el aprendizaje automático.
En el proceso de optimización, se debe aprovechar al máximo las transacciones de retroalimentación y simulación para evaluar la calidad de la señal y la estabilidad de la estrategia. Sólo los programas de optimización bien verificados se pueden aplicar en el mercado real.
Resumir
Esta estrategia en general es una buena estrategia de seguimiento de tendencias. Utiliza varios indicadores para juzgar las tendencias, establece filtros para reducir las señales erróneas y puede ajustar automáticamente las tendencias de seguimiento de stop loss. Si los parámetros están configurados correctamente, puede capturar con éxito las tendencias de la línea media y larga.
/*backtest
start: 2023-12-03 00:00:00
end: 2023-12-06 00:00:00
period: 3m
basePeriod: 1m
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/
// © RafaelZioni
//@version=4
strategy(title = " BTC 15 min", overlay = true, pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 20, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.075)
strat_dir_input = input(title="Strategy Direction", defval="all", options=["long", "short", "all"])
strat_dir_value = strat_dir_input == "long" ? strategy.direction.long : strat_dir_input == "short" ? strategy.direction.short : strategy.direction.all
strategy.risk.allow_entry_in(strat_dir_value)
price = close
length8 = input(30,title = 'length of channel')
upmult = input(title = 'upper percent',type=input.float, step=0.1, defval=5)
lowmult = input(title = 'lower percent',type=input.float, step=0.1, defval=5)
basis = sma(close, length8)
vup = upmult * price / 100
vlow = lowmult * price / 100
upper = basis + vup
lower = basis - vlow
plot(basis, color=color.red)
//
fastLength = input(3, title="Fast filter length ", minval=1)
slowLength = input(21,title="Slow filter length", minval=1)
source=close
v1=ema(source,fastLength)
v2=ema(source,slowLength)
//
leng=1
p1=close[1]
len55 = 10
//taken from https://www.tradingview.com/script/Ql1FjjfX-security-free-MTF-example-JD/
HTF = input("1D", type=input.resolution)
ti = change( time(HTF) ) != 0
T_c = fixnan( ti ? close : na )
vrsi = rsi(cum(change(T_c) * volume), leng)
pp=wma(vrsi,len55)
d=(vrsi[1]-pp[1])
len100 = 10
x=ema(d,len100)
//
zx=x/-1
col=zx > 0? color.lime : color.orange
//
tf10 = input("1", title = "Timeframe", type = input.resolution, options = ["1", "5", "15", "30", "60","120", "240","360","720", "D", "W"])
length = input(50, title = "Period", type = input.integer)
shift = input(1, title = "Shift", type = input.integer)
hma(_src, _length)=>
wma((2 * wma(_src, _length / 2)) - wma(_src, _length), round(sqrt(_length)))
hma3(_src, _length)=>
p = length/2
wma(wma(close,p/3)*3 - wma(close,p/2) - wma(close,p),p)
b =security(syminfo.tickerid, tf10, hma3(close[1], length)[shift])
//plot(a,color=color.gray)
//plot(b,color=color.yellow)
close_price = close[0]
len = input(25)
linear_reg = linreg(close_price, len, 0)
buy=crossover(linear_reg, b)
sell=crossunder(linear_reg, b) or crossunder(close[1],upper)
//
src2=low
src3=high
Min =input(15)
leni = timeframe.isintraday and timeframe.multiplier >= 1 ?
Min / timeframe.multiplier * 7 :
timeframe.isintraday and timeframe.multiplier < 60 ?
60 / timeframe.multiplier * 24 * 7 : 7
l1 = wma(src2,leni)
h1 = wma(src3,leni)
//
m=(h1+l1)/2
//
len5 = 100
src5=m
//
multi = 2
mean = ema(src5, len5)
stddev = multi * stdev(src5, len5)
b5 = mean + stddev
s5 = mean - stddev
var bool long = na
var bool short = na
long :=crossover(src5, s5)
short := crossunder(src5, b5)
var float last_open_long = na
var float last_open_short = na
last_open_long := long ? close : nz(last_open_long[1])
last_open_short := short ? close : nz(last_open_short[1])
entry_value =last_open_long
entry_value1=last_open_short
r=100
//
highb = highest(entry_value1, r)
lowb = lowest(entry_value, r)
d5 = highb - lowb
me = (highb + lowb) / 2
h4 = highb - d5 * 0.236
c3 = highb - d5 * 0.382
c4 = highb - d5 * 0.618
l4 = highb - d5 * 0.764
//
col2 = close >= me ? color.lime : color.red
p5 = plot(upper, color=col2)
p2 = plot(lower, color=col2)
fill(p5, p2,color=col2)
// Conditions
longCond = bool(na)
shortCond = bool(na)
longCond := crossover(zx,0) or buy
shortCond := sell
// Count your long short conditions for more control with Pyramiding
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if longCond
sectionLongs := sectionLongs + 1
sectionShorts := 0
sectionShorts
if shortCond
sectionLongs := 0
sectionShorts := sectionShorts + 1
sectionShorts
// Pyramiding
pyrl = 1
// These check to see your signal and cross references it against the pyramiding settings above
longCondition = longCond and sectionLongs <= pyrl
shortCondition = shortCond and sectionShorts <= pyrl
// Get the price of the last opened long or short
last_open_longCondition = float(na)
last_open_shortCondition = float(na)
last_open_longCondition := longCondition ? open : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? open : nz(last_open_shortCondition[1])
// Check if your last postion was a long or a short
last_longCondition = float(na)
last_shortCondition = float(na)
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
// Take profit
isTPl = true
//isTPs = input(false, "Take Profit Short")
tp = input(2, "Exit Profit %", type=input.float)
long_tp = isTPl and crossover(high, (1 + tp / 100) * last_open_longCondition) and longCondition == 0 and in_longCondition == 1
//short_tp = isTPs and crossunder(low, (1 - tp / 100) * last_open_shortCondition) and
//shortCondition == 0 and in_shortCondition == 1
// Stop Loss
isSLl = input(true,"buy Loss Long")
//isSLs = input(false, "buy Loss Short")
sl = 0.0
sl := input(5, " rebuy %", type=input.float)
long_sl = isSLl and crossunder(low, (1 - sl / 100) * last_open_longCondition) and
longCondition == 0 and in_longCondition == 1
//short_sl = isSLs and crossover(high, (1 + sl / 100) * last_open_shortCondition) and
//shortCondition == 0 and in_shortCondition == 1
//
// Conditions
longCond5 = bool(na)
shortCond5 = bool(na)
longCond5 := longCondition
shortCond5 := long_tp
//
sectionLongs5 = 0
sectionLongs5 := nz(sectionLongs5[1])
sectionShorts5 = 0
sectionShorts5 := nz(sectionShorts5[1])
if longCond5
sectionLongs5 := sectionLongs5 + 1
sectionShorts5 := 0
sectionShorts5
if shortCond5
sectionLongs5 := 0
sectionShorts5 := sectionShorts5 + 1
sectionShorts5
//
pyr5 = 1
longCondition5 = longCond5 and sectionLongs5 <= pyr5
shortCondition5 = shortCond5 and sectionShorts5 <= pyr5
// Get the price of the last opened long or short
last_open_longCondition5 = float(na)
last_open_shortCondition5 = float(na)
last_open_longCondition5 := longCondition5 ? open : nz(last_open_longCondition5[1])
last_open_shortCondition5 := shortCondition5 ? open : nz(last_open_shortCondition5[1])
last_longCondition5 = float(na)
last_shortCondition5 = float(na)
last_longCondition5 := longCondition5 ? time : nz(last_longCondition5[1])
last_shortCondition5 := shortCondition5 ? time : nz(last_shortCondition5[1])
in_longCondition5 = last_longCondition5 > last_shortCondition5
in_shortCondition5 = last_shortCondition5 > last_longCondition5
//
filter=input(true)
g(v, p) => round(v * (pow(10, p))) / pow(10, p)
risk = input(100)
leverage = input(1)
c = g((strategy.equity * leverage / open) * (risk / 100), 4)
//
l =(v1 > v2 or filter == false ) and longCondition or long_sl
//
//l = longCondition or long_sl
s=shortCondition5
if l
strategy.entry("buy", strategy.long,c)
if s
strategy.entry("sell", strategy.short,c)
per(pcnt) =>
strategy.position_size != 0 ? round(pcnt / 100 * strategy.position_avg_price / syminfo.mintick) : float(na)
stoploss=input(title=" stop loss", defval=5, minval=0.01)
los = per(stoploss)
q1=input(title=" qty_percent1", defval=50, minval=1)
q2=input(title=" qty_percent2", defval=50, minval=1)
tp10=input(title=" Take profit1", defval=1, minval=0.01)
tp20=input(title=" Take profit2", defval=2, minval=0.01)
strategy.exit("x1", qty_percent = q1, profit = per(tp10), loss = los)
strategy.exit("x2", qty_percent = q2, profit = per(tp20), loss = los)