La console de back-test : tester des stratégies de trading en code

Sûr par conception. Votre script s’exécute uniquement dans votre navigateur, dans un bac à sable sans accès à internet : il peut lire les bougies qu’on lui donne et rien d’autre (ni votre compte, ni ce site, ni d’autres sites). Rien de ce que vous écrivez ne tourne sur nos serveurs.

Démarrer en une minute

1. Ouvrez n’importe quel graphique, par exemple EURUSD, et choisissez l’unité de temps à tester (H1, D1…).
2. Appuyez sur Stratégie dans la barre d’outils du graphique. La console s’ouvre sous le graphique.
3. Choisissez une stratégie intégrée, par exemple Croisement de moyennes mobiles. Elle s’exécute aussitôt : des flèches sur le graphique marquent chaque entrée et sortie.
4. Modifiez un paramètre (par exemple la moyenne lente de 30 à 50) : le test se relance tout seul.
5. Lisez Vue d’ensemble pour les totaux, Trades pour chaque trade, Courbe de capital pour le compte dans le temps.
6. Appuyez sur Modifier une copie pour en faire votre propre script, modifiez-le et appuyez sur Lancer le test (ou Ctrl+Enter).

La console, élément par élément

Paramètres

Lire les résultats

L’onglet Trades liste chaque trade avec son sens, l’heure et le prix d’entrée et de sortie, la taille, le profit en argent et en %, le nombre de bougies qu’il a duré, la raison de sa clôture (signal, stop loss, take profit, retourné, encore ouvert à la fin) et votre commentaire. Télécharger le CSV l’exporte vers un tableur. La Courbe de capital montre le compte face à l’achat-conservation. Le Log montre ce que votre script a écrit avec log().

Comment les ordres sont exécutés

• Pas de regard vers l’avant. Un ordre passé dans onBar(i) est exécuté à l’ouverture de la bougie suivante (i + 1). Une stratégie ne peut jamais trader à un prix qu’elle ne pouvait pas connaître.
• Stops dans la bougie. Stop loss et take profit sont vérifiés par rapport au plus haut et au plus bas de chaque bougie. Si les deux pouvaient être atteints dans la même bougie, c’est le stop qui compte (l’hypothèse prudente). Un gap à travers un stop est exécuté à l’ouverture, comme sur les marchés réels.
• Une position à la fois. long() pendant une vente clôture la vente et ouvre un achat (« retourné ») ; long() alors qu’on est déjà acheteur ne met à jour que les stops passés.
• Des coûts à chaque exécution. Le slippage déplace chaque prix d’exécution en votre défaveur ; la commission est prélevée à l’entrée et à la sortie.
• La fin. Un trade encore ouvert après la dernière bougie est clôturé à la dernière clôture et marqué « encore ouvert à la fin ».

Écrire votre propre stratégie

Une stratégie est un court programme JavaScript en deux parties :

1. Le début s’exécute une fois : lisez vos paramètres avec input(), calculez des séries entières avec ta.* ou ind(), et tracez-les avec plot().
2. function onBar(i) { … } s’exécute pour chaque bougie, de la plus ancienne à la plus récente. i est le numéro de la bougie (0 = la plus ancienne). C’est ici que vous décidez : long(), short(), exit() ou rien.

// 1. once: inputs and series
const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);           // one value per candle
plot(avg, "SMA " + len, "#2F80ED");       // drawn on the price chart

// 2. every candle
function onBar(i) {
  if (avg[i] == null) return;             // the first len - 1 values are null (warming up)
  if (position === 0 && close[i] > avg[i]) long();
  if (position > 0 && close[i] < avg[i]) exit("below the average");
}

Bon à savoir dès le départ :

• Les séries sont des tableaux, une valeur par bougie, de la plus ancienne à la plus récente : close[i] est la clôture de cette bougie, close[i - 1] celle d’avant. Les séries calculées valent null tant qu’elles n’ont pas assez de bougies ; vérifiez avant de les utiliser.
• Dans onBar(i), vous ne pouvez lire les bougies que jusqu’à i. close[i + 1] arrête le test avec une erreur : ce serait regarder dans le futur.
• Utilisez const et let comme d’habitude ; vos propres variables gardent leur valeur d’une bougie à l’autre (pratique pour un stop suiveur).
• Les prix sont dans les unités du graphique (pour EURUSD 1,0850, pour l’or 2650,40) ; le temps est en secondes UTC.

Référence

Bougies et état actuel

Paramètres

Jusqu’à 30 paramètres. Leurs valeurs sont enregistrées avec la stratégie et l’accompagnent quand vous la publiez dans une idée.

Calculs (ta.*)

src est n’importe quelle série : close, high, un autre résultat ou votre propre tableau. Chaque fonction renvoie un nouveau tableau ; rien ne modifie les bougies.

Signaux

Ordres

Sortie

Les 71 indicateurs du graphique dans le code : ind()

ind(id, inputs) calcule n’importe quel indicateur du graphique exactement comme le graphique. Il renvoie sa première ligne sous forme de série ; toutes les lignes sont dans .lines et leurs noms dans .names. Les paramètres omis prennent la valeur par défaut indiquée. method vaut SMA, EMA, SMMA ou LWMA ; price vaut close, open, high, low, median, typical ou weighted.

const st = ind("stoch", { k: 14, d: 3, slowing: 3 });   // st = %K, st.lines[1] = %D
const ich = ind("ichimoku");                            // ich.names: Tenkan, Kijun, Span A, Span B, Chikou
const kijun = ich.lines[1];

Exemples

Chaque exemple fonctionne tel quel : appuyez sur Copier, ouvrez la console, choisissez Nouveau script…, collez et appuyez sur Lancer le test. Les résultats dépendent du symbole, de l’unité de temps et de la période ; les exemples enseignent la technique, ce ne sont pas des recommandations.

const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);
plot(avg, "SMA " + len, "#2F80ED");

function onBar(i) {
  if (avg[i] == null) return;                 // still warming up
  if (position === 0 && close[i] > avg[i]) long({ comment: "close above the average" });
  if (position > 0 && close[i] < avg[i]) exit("close below the average");
}

const fast = ta.ema(close, input("Fast EMA", 12, { min: 2, max: 200 }));
const slow = ta.ema(close, input("Slow EMA", 26, { min: 3, max: 400 }));
plot(fast, "Fast", "#2F80ED");
plot(slow, "Slow", "#E39B2D");

function onBar(i) {
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const r = ta.rsi(close, 14);
const sl = input("Stop loss %", 1.5, { min: 0.1, max: 20, step: 0.1 });
const tp = input("Take profit %", 3, { min: 0.1, max: 50, step: 0.1 });

function onBar(i) {
  if (position !== 0) return;                 // one trade at a time
  if (ta.crossover(r, 30, i)) long({ slPct: sl, tpPct: tp, comment: "RSI back above 30" });
  if (ta.crossunder(r, 70, i)) short({ slPct: sl, tpPct: tp, comment: "RSI back below 70" });
}

const a = ta.atr(14);
const hi = ta.highest(high, 20);
const mult = input("Stop (ATR multiple)", 2, { min: 0.5, max: 6, step: 0.5 });

function onBar(i) {
  if (i < 1 || a[i] == null || hi[i - 1] == null || position !== 0) return;
  if (close[i] > hi[i - 1]) {                  // a new 20-candle high
    const stop = close[i] - mult * a[i];
    const target = close[i] + 2 * mult * a[i];
    long({ sl: stop, tp: target, comment: "breakout, risk " + (mult * a[i]).toFixed(5) });
  }
}

const a = ta.atr(14);
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);
let stop = null;

function onBar(i) {
  if (a[i] == null || slow[i] == null) return;
  if (position === 0) {
    stop = null;
    if (ta.crossover(fast, slow, i)) long({ comment: "trend up" });
    return;
  }
  const candidate = close[i] - 3 * a[i];
  if (stop === null || candidate > stop) {     // only ever raise it
    stop = candidate;
    stopLoss(stop);
  }
}

const adx = ind("adx", { period: 14 });      // .lines[0] ADX, [1] +DI, [2] -DI
const plusDI = adx.lines[1], minusDI = adx.lines[2];
const m = ta.macd(close, 12, 26, 9);
const minAdx = input("Minimum ADX", 25, { min: 10, max: 50 });

function onBar(i) {
  if (adx[i] == null || adx[i] < minAdx) return;
  if (ta.crossover(m.macd, m.signal, i) && plusDI[i] > minusDI[i]) long();
  if (ta.crossunder(m.macd, m.signal, i) && minusDI[i] > plusDI[i]) short();
}

const b = ta.bb(close, input("Period", 20, { min: 5, max: 200 }), input("Width", 2, { min: 0.5, max: 4, step: 0.1 }));
plot(b.upper, "Upper", "#8E44AD");
plot(b.lower, "Lower", "#8E44AD");

function onBar(i) {
  if (b.middle[i] == null) return;
  if (position === 0 && close[i] < b.lower[i]) long({ comment: "below the lower band" });
  else if (position === 0 && close[i] > b.upper[i]) short({ comment: "above the upper band" });
  else if (position > 0 && close[i] >= b.middle[i]) exit("middle band");
  else if (position < 0 && close[i] <= b.middle[i]) exit("middle band");
}

const from = input("Start hour (UTC)", 7, { min: 0, max: 23 });
const to = input("End hour (UTC)", 16, { min: 1, max: 24 });
const fast = ta.sma(close, 10), slow = ta.sma(close, 30);

function onBar(i) {
  const hour = new Date(time[i] * 1000).getUTCHours();
  if (position !== 0 && hour >= 20) { exit("end of the day"); return; }
  if (hour < from || hour >= to) return;
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const k = input("Range multiple", 0.5, { min: 0.1, max: 2, step: 0.1 });
const range = high.map((h, i) => (i ? high[i - 1] - low[i - 1] : null));   // the previous candle's range
const trigger = open.map((o, i) => (range[i] == null ? null : o + k * range[i]));
plot(trigger, "Trigger", "#16A085");

function onBar(i) {
  if (trigger[i] == null) return;
  if (position === 0 && close[i] > trigger[i]) {
    long({ slPct: 1, comment: "close above open + " + k + " x range" });
    log("signal at", close[i], "trigger", trigger[i]);
  } else if (position > 0 && i - entryBar >= 3) {
    exit("held 3 candles");
  }
}

const a = ta.atr(14);
const riskPct = input("Risk per trade %", 1, { min: 0.1, max: 5, step: 0.1 });
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);

function onBar(i) {
  if (a[i] == null || slow[i] == null || position !== 0) return;
  if (ta.crossover(fast, slow, i)) {
    const stopDistance = 2 * a[i];
    const qty = (equity * riskPct / 100) / stopDistance;
    long({ qty: qty, sl: close[i] - stopDistance, tp: close[i] + 3 * stopDistance,
           comment: "risk " + riskPct + "%" });
  }
}

const trend = ta.sma(close, 200), fast = ta.ema(close, 20), r = ta.rsi(close, 14);

function onBar(i) {
  if (trend[i] == null || i < 5) return;
  let dipped = false;
  for (let k = 0; k < 5; k++) if (r[i - k] != null && r[i - k] < 40) dipped = true;
  if (position === 0 && close[i] > trend[i] && dipped && ta.crossover(close, fast, i)) {
    long({ slPct: 2, tpPct: 4, comment: "pullback bought" });
  }
}

Les erreurs et comment les corriger

Des tests fiables

• Ajoutez vos coûts. Une stratégie qui trade souvent peut sembler excellente sans coûts et perdre de l’argent avec un spread réaliste. Renseignez toujours le slippage (le spread) et la commission.
• Utilisez assez de trades. En dessous d’environ 30 trades, les chiffres relèvent surtout du hasard. Chargez plus de bougies ou utilisez une unité de temps plus courte.
• N’ajustez pas au passé. Essayer de nombreux paramètres jusqu’à un résultat parfait trouve le bruit de cette période, pas une règle qui fonctionne. Réglez sur une partie de l’historique, puis vérifiez les mêmes paramètres sur une autre période et sur quelques autres symboles.
• Comparez avec l’achat-conservation et regardez le drawdown, pas seulement le profit.
• Surveillez les extrêmes. Si un ou deux trades font tout le profit, la stratégie dépend de la chance.
• Entraînez-vous avant de risquer de l’argent. Faites tourner la stratégie en avant en trading fictif ou avec le replay des barres, et créez des alertes pour ses signaux.

Les back-tests utilisent les bougies bid passées et ignorent les swaps, le financement et les spreads qui varient avec le marché. Les résultats passés ne garantissent pas les résultats futurs. Ceci n’est pas un conseil en investissement.

Enregistrer, partager, publier

• Enregistrer (connecté) conserve jusqu’à 50 stratégies avec leurs paramètres et réglages ; elles apparaissent dans la liste sur chaque graphique.
• Publiez une idée depuis le graphique et joignez une stratégie : les lecteurs peuvent ouvrir votre graphique et lancer eux-mêmes la stratégie avec vos paramètres. Voir Idées.
• Partagez votre analyse avec une équipe dans un club.
• Télécharger le CSV dans l’onglet Trades exporte les trades vers un tableur.
• Pour une recherche plus poussée, récupérez les mêmes bougies avec l’API de prix (GET /bars) dans Python, R ou Excel.

Limites

Questions