Ce que l'utilisateur décrit et ce que le moteur prend en charge

Le mode Algo prend en charge tout le backtest d'une stratégie sur un actif. L'utilisateur décrit sa logique : indicateurs, conditions d'entrée et règles de gestion. Le moteur applique le modèle d'exécution, puis renvoie les rendements, les métriques et le journal des trades.

Utiliser une donnée H1 seulement après la clôture de sa bougie

Une feature est une fonction qui lit les colonnes du moteur, par exemple f.col("Close"), et renvoie une ou plusieurs séries. Les colonnes calculées rejoignent ensuite le moteur, et les règles de sortie peuvent les utiliser par leur nom.

feature.add(
    my_indicator, "h1_trend",
    on_ohlcv_matrix="algo_h1", matrix_asset="XAUUSD",
    align_to="main", availability="bar_close",
    source_tf="H1", max_age="2h",
)

BacktestConfig fixe ensuite le timing, les sessions, les filtres de bougies, le nombre maximal d'entrées, le cooldown et les sorties par défaut. Avec entry_delay=1, l'entrée se fait à l'ouverture de la bougie suivante ; une exécution sur la bougie du signal serait souvent trop optimiste.

Décrire la gestion des positions, du réglage simple à la fonction compilée

Deux stratégies qui partagent le même signal peuvent obtenir des résultats très différents selon la façon dont leurs positions sont gérées. Le moteur permet de décrire cette gestion à quatre niveaux, chacun plus précis que le précédent :

Avec les phases, une position commence en phase 0. Une règle peut se déclencher sur une excursion, un multiple du risque, un nombre de barres, une feature ou une combinaison de conditions. Elle peut alors prendre un bénéfice partiel, déplacer le stop, changer l'objectif, renforcer la position ou passer à la phase suivante.

PartialConfig, PyramidConfig et AveragingConfig décrivent respectivement les sorties échelonnées, les ajouts aux positions gagnantes et les ajouts aux positions perdantes. Un état global peut aussi limiter le nombre de positions simultanées ou imposer une pause après plusieurs stops consécutifs.

Passer du prix théorique au prix exécuté, puis à la taille de position

execution_costs = ExecutionCostSpec(
    enabled=True, product_type="cfd",
    contract_spec=ContractSpec(instrument_id="XAUUSD",
                               contract_size=100.0, quote_currency="USD"),
    spread_points=0.02,                      # écart de prix, pas un %
    commission_per_lot_round_turn_usd=3.0,   # entrée + sortie
    slippage=SlippageSpec(enabled=True, adverse_only=True,
                          model="simple_range", simple_range_frac=0.0025,
                          stop_market_mult=1.25),
)

rets, metrics, tape = engine.run(..., execution_costs=execution_costs,
                                 return_tape=True)
sized = engine.run_sizing(tape=tape, sizing=sizing,
                          execution_costs=execution_costs,
                          strict_tape_context=True)

Synthèse renvoyée par run_sizing, stratégie de démonstration non validée

Trades	2 714
Taux de gain	17,2 %
Somme des rendements	+429,25 %
Rendement cumulé	+1 905,21 %
Rendement annualisé	+189,52 %
Drawdown maximal	−56,05 %
Sharpe	2,772
Profit factor	1,140
Calmar	3,381
Gain moyen / perte moyenne	+5,917 % / −1,042 %

Le break-even est armé sur une bougie et devient actif à la suivante ; sa sortie porte le libellé BE. Un mode optionnel traite la cible comme un ordre limite, avec un état d'attente et des événements de non-exécution.

Retrouver pour chaque sortie sa raison, ses prix et ses coûts

metrics["trades_df"] rassemble pour chaque trade le sens, les bougies d'entrée et de sortie, les prix visés et exécutés, le rendement brut et net, les excursions, le setup, le profil et la phase. Les colonnes de coûts permettent de revenir sur chaque exécution.

Une sortie partielle forme une ligne distincte, avec le même trade_uid que le trade d'origine. Compter les lignes ne suffit donc pas à compter les positions.

Vérifier que le signal apporte quelque chose, à gestion identique

Pour tester une idée de gestion, il suffit de conserver les entrées et de ne changer que le profil de sortie. Comparer les rendements en multiples du risque, le drawdown et le temps de récupération année par année permet ensuite de situer l'effet dans le temps.

Pour tester le signal lui-même, la référence aléatoire doit poser la même question. random_entry_keep_exit_logic relance le moteur avec des entrées tirées au hasard et la même logique de sortie. Une référence à durée de détention fixe, qui ignore stops et objectifs, ne répond pas à cette question.

engine.report_random_baseline(
    metrics=metrics,
    null_model="random_entry_keep_exit_logic",
    n_sim=20,
)

La validation se déclare dans le constructeur, avant les premiers essais : compteur d'essais, freeze, hors échantillon sur l'actif, puis cross-asset. DSR, Monte-Carlo, rétention hors échantillon, concentration de l'edge et dépendance aux valeurs extrêmes apportent des lectures complémentaires.

Voir un parcours de validation complet, publié sur le mode allocation →

Afficher le backtest dans le graphique du mode Research

Research sert en amont à écrire et examiner l'indicateur. Algo ajoute les règles d'entrée, la gestion, l'exécution et le risque. Ces choix doivent être formalisés : partager la vue ne transforme pas automatiquement une étude en stratégie.

@engine.research_view(name="Showcase · EMA 50/100 · régime H1",
                      asset="XAUUSD", pip_size=0.01)
def plot_showcase(plot, c):
    price = plot.price()
    price.line(c.ema1, name="EMA 50", stroke=Stroke(color="#FFB74D", width=1.5))
    price.line(c.ema2, name="EMA 100", stroke=Stroke(color="#64B5F6", width=1.5))
    price.regime(c.regime, mode="box", bounds="segment_ohlc", styles=regime_styles)
    # bougies, entrées et sorties exécutées ajoutées automatiquement

Savoir ce qui demande une recompilation, et ce qui reste à vérifier

Les profils et les règles sont transformés en matrices de paramètres : les modifier ne demande pas de recompiler un noyau déjà chargé. Modifier une fonction @njit du package invalide en revanche son cache.

Ces durées sont mesurées sur l'environnement de développement et ne constituent pas un benchmark. C'est aussi pour éviter ce coût que le mode Research étudie un signal sans compilation.

Limites connues