1. Carré
  2. Stratégie de contre-test dynamique sur plusieurs délais

Stratégie de contre-test dynamique sur plusieurs délais

Auteur:ChaoZhang est là., Date: 2023-11-21 17h07
Les étiquettes:

img

Résumé

Cette stratégie utilise un mécanisme de backtesting dynamique à plusieurs délais pour déterminer les tendances des prix en comparant les prix les plus élevés et les plus bas au cours de différentes périodes, ce qui permet d'obtenir un arbitrage à faible risque.

La logique de la stratégie

La stratégie récupère le prix le plus élevé (nhigh) et le prix le plus bas (nlow) sur différentes périodes en appelant la fonction personnalisée f_get_htfHighLow. Plus précisément, basée sur des entrées définies par l'utilisateur telles que la résolution de la période, le multiplicateur de période HTFMultiplier, les paramètres de backtesting lookhead et les lacunes, et le décalage, elle appelle la fonction de sécurité pour obtenir les prix les plus élevés et les plus bas sur différentes périodes.

Par exemple, un décalage de 0 récupère les prix les plus élevés et les plus bas de la barre actuelle, tandis qu'un décalage de 1 récupère ces prix de la barre précédente.

Si les prix les plus élevés et les plus bas augmentent, une tendance haussière est identifiée. Si les deux prix baissent, une tendance baissière est observée. Des positions longues ou courtes sont prises en fonction de la direction de la tendance pour mettre en œuvre des transactions d'arbitrage.

Les avantages

  1. Amélioration de la précision grâce à l'analyse sur plusieurs périodes
  2. Évite de repeindre via le backtesting dynamique
  3. Paramètres flexibles pour tenir compte des changements du marché
  4. Risque réduit avec des positions ne présentant que des tendances claires

Les risques

  1. Des erreurs d'appréciation sur plusieurs périodes
  2. Repeindre à partir de paramètres de backtesting incorrects
  3. Coûts élevés et dérapage dus à des transactions excessives

Les solutions:

  1. Optimiser les périodes de temps pour la précision
  2. Les paramètres de test doivent être strictement vérifiés pour éviter la repeinture
  3. Conditions d'entrée modérées pour contrôler la fréquence

Des possibilités d'amélioration

  1. Ajouter de l'apprentissage automatique pour tirer parti de l'IA pour les tendances
  2. Incorporer des filtres de volatilité pour la dimensionnement dynamique des positions
  3. Mettre en place des arrêts pour limiter efficacement les pertes

Conclusion

La logique de la stratégie est claire, en utilisant le backtesting dynamique sur plusieurs délais pour déterminer les tendances et minimiser les biais humains.

/*backtest
start: 2022-11-14 00:00:00
end: 2023-11-20 00:00:00
period: 1d
basePeriod: 1h
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/
// © HeWhoMustNotBeNamed

//@version=4
strategy("HTF High/Low Repaint Strategy", overlay=true, initial_capital = 20000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, pyramiding = 1, commission_value = 0.01)

i_startTime = input(defval = timestamp("01 Jan 2010 00:00 +0000"), title = "Start Time", type = input.time)
i_endTime = input(defval = timestamp("01 Jan 2099 00:00 +0000"), title = "End Time", type = input.time)
inDateRange = true

resolution = input("3M", type=input.resolution)
HTFMultiplier = input(22, minval=1, step=1)
offset = input(0, minval=0, step=1)
lookahead = input(true)
gaps = false

f_secureSecurity_on_on(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_on, gaps=barmerge.gaps_on)
f_secureSecurity_on_off(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_on, gaps=barmerge.gaps_off)
f_secureSecurity_off_on(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_off, gaps=barmerge.gaps_on)
f_secureSecurity_off_off(_symbol, _res, _src, _offset) => security(_symbol, _res, _src[_offset], lookahead = barmerge.lookahead_off, gaps=barmerge.gaps_off)

f_multiple_resolution(HTFMultiplier) => 
    target_Res_In_Min = timeframe.multiplier * HTFMultiplier * (
      timeframe.isseconds   ? 1. / 60. :
      timeframe.isminutes   ? 1. :
      timeframe.isdaily     ? 1440. :
      timeframe.isweekly    ? 7. * 24. * 60. :
      timeframe.ismonthly   ? 30.417 * 24. * 60. : na)

    target_Res_In_Min     <= 0.0417       ? "1S"  :
      target_Res_In_Min   <= 0.167        ? "5S"  :
      target_Res_In_Min   <= 0.376        ? "15S" :
      target_Res_In_Min   <= 0.751        ? "30S" :
      target_Res_In_Min   <= 1440         ? tostring(round(target_Res_In_Min)) :
      tostring(round(min(target_Res_In_Min / 1440, 365))) + "D"

f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset)=>
    derivedResolution = resolution == ""?f_multiple_resolution(HTFMultiplier):resolution
    nhigh_on_on = f_secureSecurity_on_on(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_on_on = f_secureSecurity_on_on(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_on_off = f_secureSecurity_on_off(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_on_off = f_secureSecurity_on_off(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_off_on = f_secureSecurity_off_on(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_off_on = f_secureSecurity_off_on(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh_off_off = f_secureSecurity_off_off(syminfo.tickerid, derivedResolution, high, offset) 
    nlow_off_off = f_secureSecurity_off_off(syminfo.tickerid, derivedResolution, low, offset)
    
    nhigh = lookahead and gaps ? nhigh_on_on :
             lookahead and not gaps ? nhigh_on_off :
             not lookahead and gaps ? nhigh_off_on :
             not lookahead and not gaps ? nhigh_off_off : na
    nlow = lookahead and gaps ? nlow_on_on :
             lookahead and not gaps ? nlow_on_off :
             not lookahead and gaps ? nlow_off_on :
             not lookahead and not gaps ? nlow_off_off : na
    [nhigh, nlow]
    
[nhigh, nlow] = f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset)
[nhighlast, nlowlast] = f_get_htfHighLow(resolution, HTFMultiplier, lookahead, gaps, offset+1)
plot(nhigh , title="HTF High",style=plot.style_circles, color=color.green, linewidth=1) 
plot(nlow , title="HTF Low",style=plot.style_circles, color=color.red, linewidth=1)

buyCondition = nhigh > nhighlast and nlow > nlowlast
sellCondition = nhigh < nhighlast and nlow < nlowlast

strategy.entry("Buy", strategy.long, when= buyCondition and inDateRange, oca_name="oca_buy")
strategy.entry("Sell", strategy.short, when= sellCondition and inDateRange, oca_name="oca_sell")
Plus de

2019 FMZ - Tous les droits réservés