Rétrotest du tableau de bord macro de l'or : le signal est-il efficace ?

Pourquoi refaire le test de la carte de pointage macro-or ?

Dans l' article qui accompagne Prédire les prix de l'or à l'aide de données macro, nous avons construit un tableau de bord macro composite qui assigne des signaux directionnels à six indicateurs macro américains TIPS 10Y rendement réel, inflation de rupture, taux de la Fed, actifs totaux de la FED, offre monétaire M2 et le dollar pondéré par le commerce et les agrégent en un biais d'or net. Le tableau de score vous indique si le régime macro favorise l'or. Mais fonctionne-t-il vraiment?

Cet article répond à cette question en effectuant un backtest systématique contre quotidienne prix de l' or à partir de la FXMacroData point final des produits de baseNous calculerons le scorecard à chaque publication de données macro, maintenirons une position simple longue/plate en or basée sur le signal net, et mesurerons si ce signal a produit des rendements significatifs au-dessus de l'achat et de la détention.

Étape 1: Récupérez les prix quotidiens de l'or et les séries macro

Le fondement du backtest est le prix quotidien de l' or du FXMacroData Produits de base/or Les prix sont fixés en USD par once troy. Contrairement aux données mensuelles ou hebdomadaires agrégées, les prix quotidiens permettent de mesurer l'impact précis de chaque transition de signal macro.

import requests
import pandas as pd
from datetime import date

BASE = "https://fxmacrodata.com/api/v1"
KEY  = "YOUR_API_KEY"

def get_series(path: str, start: str = "2020-01-01") -> pd.DataFrame:
    """Fetch a time series and return as a DataFrame with date index."""
    r = requests.get(f"{BASE}{path}", params={"api_key": KEY, "start_date": start})
    r.raise_for_status()
    data = r.json().get("data", [])
    df = pd.DataFrame(data)
    if not df.empty:
        df["date"] = pd.to_datetime(df["date"])
        df = df.set_index("date").sort_index()
    return df

# Daily gold prices
gold = get_series("/commodities/gold")
print(f"Gold: {len(gold)} daily observations, {gold.index[0].date()} to {gold.index[-1].date()}")
# Gold: ~1350 daily observations, 2020-01-02 to 2026-04-15

Ensuite, tirez les six séries d'indicateurs macro qui alimentent la carte de score. Ceux-ci sont publiés à différentes fréquences certains hebdomadaires (rendement TIPS, point de rentabilité), certains mensuels (IPC, M2), certains à des dates FOMC (taux de la politique) mais chaque observation persiste comme la valeur "courante" jusqu'à la prochaine publication.

# Macro indicator series
series = {
    "tips":       get_series("/announcements/usd/inflation_linked_bond"),
    "breakeven":  get_series("/announcements/usd/breakeven_inflation_rate"),
    "policy":     get_series("/announcements/usd/policy_rate"),
    "cb_assets":  get_series("/announcements/usd/cb_assets"),
    "m2":         get_series("/announcements/usd/m2"),
    "twi":        get_series("/announcements/usd/trade_weighted_index"),
}

for name, df in series.items():
    print(f"  {name:12s}: {len(df):4d} obs  ({df.index[0].date()} – {df.index[-1].date()})")

Étape 2: aligner la série et remplir en avant

Mélangez toutes les séries macro à l'indice de date d'or quotidien. Chaque valeur macro est remplie à l"avant reportée de sa date de sortie jusqu'à la prochaine sortie de sorte que le backtest n'utilise jamais d'informations futures.

# Align all series to the daily gold date index
aligned = gold[["val"]].rename(columns={"val": "gold"}).copy()

for name, df in series.items():
    # Reindex to gold dates and forward-fill
    macro = df[["val"]].rename(columns={"val": name})
    macro = macro.reindex(aligned.index, method="ffill")
    aligned = aligned.join(macro)

# Drop rows where any macro series hasn't started yet
aligned = aligned.dropna()
print(f"Aligned dataset: {len(aligned)} trading days")
print(aligned.tail())

Étape 3: Calculer le signal quotidien de la carte de pointage

Chaque jour de négociation, nous calculons le même tableau de bord à partir de l'article original mais au lieu de comparer les deux dernières observations, nous comparons la valeur actuelle remplie à terme à la valeur de 30 jours civils auparavant.

LOOKBACK = 30  # calendar days for direction detection

def score_column(col: pd.Series, mode: str) -> pd.Series:
    """Score a macro series: +1 bullish gold, 0 neutral, -1 bearish."""
    prev = col.shift(LOOKBACK)
    change = col - prev

    if mode == "falling":
        return pd.Series(
            [1.0 if c < -0.05 else (-1.0 if c > 0.05 else 0.0) for c in change],
            index=col.index
        )
    elif mode == "rising":
        return pd.Series(
            [1.0 if c > 0.05 else (-1.0 if c < -0.05 else 0.0) for c in change],
            index=col.index
        )
    elif mode == "negative":
        return pd.Series(
            [1.0 if v < 0 else (-1.0 if v > 1.0 else 0.0) for v in col],
            index=col.index
        )
    return pd.Series(0.0, index=col.index)


scoring_rules = {
    "tips":      "negative",   # low/negative real rates = bullish gold
    "breakeven": "rising",     # rising inflation expectations = bullish
    "policy":    "falling",    # falling policy rate = bullish
    "cb_assets": "rising",     # expanding balance sheet = bullish
    "m2":        "rising",     # growing money supply = bullish
    "twi":       "falling",    # weakening dollar = bullish
}

for name, mode in scoring_rules.items():
    aligned[f"sig_{name}"] = score_column(aligned[name], mode)

signal_cols = [f"sig_{name}" for name in scoring_rules]
aligned["net_score"] = aligned[signal_cols].sum(axis=1)

print(aligned[["gold", "net_score"]].tail(10))

Étape 4: Définir les règles de négociation

Le backtest utilise un ensemble de règles simples et réalistes:

• Le signal est long: Lorsque le scorecard net est ≥ +2, on passe à l'or (nous sommes en position de voir l'argent s'apprécier).
• Signal à plat: Lorsque la carte de pointage nette est inférieure à +2, conserver la position en espèces (pas de position en or).
• Pas de vente à découvert: Le tableau de bord macroéconomique identifie les régimes favorables pour l'or il ne génère pas de signaux à court terme avec la même confiance.
• Pas de levier: La position est soit 100% en or ou 100% en espèces.
• Rééquilibrage quotidien: Le signal est évalué à la fin de la journée; les modifications de position s'appliquent au rendement du jour de négociation suivant.
• Coûts de la transaction: Nous déduisons 5 points de base par transaction aller-retour (entrée + sortie) pour tenir compte de l'écart et du glissement sur un ETF or ou un contrat à terme.

# Trading rules
THRESHOLD = 2.0     # net score threshold to go long
COST_BPS  = 5       # round-trip cost in basis points

# Daily gold returns
aligned["gold_ret"] = aligned["gold"].pct_change()

# Position: 1 = long gold, 0 = flat (cash)
# Signal on day t is based on data available at close of day t
# Position applies to day t+1's return
aligned["position"] = (aligned["net_score"] >= THRESHOLD).astype(float)

# Detect trade events (position changes)
aligned["trade"] = aligned["position"].diff().abs()
aligned.loc[aligned.index[0], "trade"] = 0  # no trade on first day

# Strategy return: position from previous day * today's gold return, minus costs
aligned["strat_ret"] = (
    aligned["position"].shift(1) * aligned["gold_ret"]
    - aligned["trade"].shift(1) * (COST_BPS / 10_000)
)

# Cumulative returns
aligned["gold_cum"]  = (1 + aligned["gold_ret"]).cumprod()
aligned["strat_cum"] = (1 + aligned["strat_ret"].fillna(0)).cumprod()

print(f"Buy-and-hold return: {(aligned['gold_cum'].iloc[-1] - 1) * 100:.1f}%")
print(f"Strategy return:     {(aligned['strat_cum'].iloc[-1] - 1) * 100:.1f}%")

Étape 5: Mesurer les performances

Les indicateurs ajustés au risque nous indiquent si la surperformance de la stratégie est due à la compétence (timing du régime macro) ou simplement à la prise de plus de risques.

import numpy as np

def performance_stats(returns: pd.Series, trades: pd.Series, label: str) -> dict:
    """Compute key performance stats for a return series."""
    total_ret = (1 + returns).prod() - 1
    ann_ret   = (1 + total_ret) ** (252 / len(returns)) - 1
    ann_vol   = returns.std() * np.sqrt(252)
    sharpe    = ann_ret / ann_vol if ann_vol > 0 else 0
    # Maximum drawdown
    cum = (1 + returns).cumprod()
    peak = cum.cummax()
    dd = (cum - peak) / peak
    max_dd = dd.min()
    # Win rate
    invested_days = returns[returns != 0]
    win_rate = (invested_days > 0).mean() if len(invested_days) > 0 else 0
    n_trades = int(trades.sum() / 2)  # round trips

    return {
        "label":        label,
        "total_return":  f"{total_ret * 100:.1f}%",
        "annual_return": f"{ann_ret * 100:.1f}%",
        "annual_vol":    f"{ann_vol * 100:.1f}%",
        "sharpe_ratio":  f"{sharpe:.2f}",
        "max_drawdown":  f"{max_dd * 100:.1f}%",
        "win_rate":      f"{win_rate * 100:.1f}%",
        "trades":        n_trades,
    }

strat_stats = performance_stats(
    aligned["strat_ret"].dropna(),
    aligned["trade"].fillna(0),
    "Macro Scorecard"
)
bnh_stats = performance_stats(
    aligned["gold_ret"].dropna(),
    pd.Series(0, index=aligned.index),
    "Buy & Hold"
)

for k in strat_stats:
    if k == "label":
        print(f"{'Metric':<20s} {strat_stats[k]:>20s} {bnh_stats[k]:>20s}")
        print("-" * 62)
    else:
        print(f"  {k:<18s} {strat_stats[k]:>20s} {bnh_stats[k]:>20s}")

Étape 6: Analyse des retombées et qualité du signal

La proposition de valeur la plus importante d'un modèle de macro-timing n'est pas de capturer chaque mouvement à la hausse, mais d'éviter les pires mouvements à la baisse.

# Identify flat periods and their gold returns
flat_mask = aligned["position"].shift(1) == 0
flat_gold_ret = aligned.loc[flat_mask, "gold_ret"]
long_gold_ret = aligned.loc[~flat_mask, "gold_ret"]

print(f"Days long gold:       {(~flat_mask).sum()}")
print(f"Days flat (cash):     {flat_mask.sum()}")
print(f"Avg daily ret (long): {long_gold_ret.mean()*100:.3f}%")
print(f"Avg daily ret (flat): {flat_gold_ret.mean()*100:.3f}%")
print(f"Avoided loss days:    {(flat_gold_ret < 0).sum()} "
      f"(total loss: {flat_gold_ret[flat_gold_ret < 0].sum()*100:.1f}%)")

Le retrait de 2022 en est l'exemple le plus clair. Alors que la Fed a augmenté les taux de manière agressive de mars à octobre 2022, le rendement TIPS 10Y est passé de près de zéro à +1,6%, le dollar pondéré par le commerce s'est fortement apprécié et la croissance de M2 est devenue négative. La carte de score a correctement lu les trois signaux comme baissiers et a été déplacée vers l'argent liquide, évitant la majeure partie de la baisse de l'or de ~ 20% du pic au creux.

Étape 7: Décomposition du régime du signal

Les niveaux de la carte de pointage ne sont pas tous égaux.

# Forward 20-day gold return by score level
aligned["fwd_20d"] = aligned["gold"].pct_change(20).shift(-20)

regime_stats = (
    aligned.groupby("net_score")["fwd_20d"]
    .agg(["mean", "std", "count"])
    .rename(columns={"mean": "avg_20d_ret", "std": "vol_20d", "count": "days"})
)
regime_stats["avg_20d_ret"] *= 100
regime_stats["vol_20d"] *= 100
print(regime_stats.round(2))

Étape 8: vérification de la robustesse

Une configuration unique de backtest peut surpasser. Ici, nous vérifions que le résultat n'est pas fragile en modifiant les paramètres clés.

Sensitivité limite

results = []
for thresh in range(-2, 6):
    pos = (aligned["net_score"] >= thresh).astype(float)
    ret = pos.shift(1) * aligned["gold_ret"]
    trades = pos.diff().abs().fillna(0)
    ret -= trades.shift(1) * (COST_BPS / 10_000)
    cum = (1 + ret.fillna(0)).prod()
    vol = ret.std() * np.sqrt(252)
    ann = cum ** (252 / len(ret)) - 1
    sharpe = ann / vol if vol > 0 else 0
    results.append({"threshold": thresh, "total_ret": f"{(cum-1)*100:.1f}%",
                    "sharpe": round(sharpe, 2), "pct_invested": f"{pos.mean()*100:.0f}%"})

pd.DataFrame(results).set_index("threshold")

Sensitivité à la période de rétrospective

for lb in [15, 30, 60, 90]:
    # Recompute scores with different lookback
    sig_sum = pd.Series(0.0, index=aligned.index)
    for name, mode in scoring_rules.items():
        prev = aligned[name].shift(lb)
        chg  = aligned[name] - prev
        if mode == "falling":
            sig = pd.Series([1 if c < -0.05 else (-1 if c > 0.05 else 0) for c in chg], index=aligned.index)
        elif mode == "rising":
            sig = pd.Series([1 if c > 0.05 else (-1 if c < -0.05 else 0) for c in chg], index=aligned.index)
        elif mode == "negative":
            sig = pd.Series([1 if v < 0 else (-1 if v > 1 else 0) for v in aligned[name]], index=aligned.index)
        else:
            sig = pd.Series(0, index=aligned.index)
        sig_sum += sig
    pos = (sig_sum >= THRESHOLD).astype(float)
    ret = pos.shift(1) * aligned["gold_ret"]
    cum = (1 + ret.fillna(0)).prod()
    vol = ret.std() * np.sqrt(252)
    ann = cum ** (252/len(ret)) - 1
    print(f"  Lookback {lb:3d}d: return {(cum-1)*100:+.1f}%  Sharpe {ann/vol:.2f}")

Étape 9: Le script complet de test de retour

Voici un backtest complet et autonome qui récupère toutes les données de FXMacroData, exécute la stratégie de la carte de score et imprime un résumé de performance avec une sortie prête pour le graphique.

"""
Gold Macro Scorecard Backtest
Fetches daily gold prices and macro series from FXMacroData,
computes the composite scorecard, and evaluates a long/flat strategy.
"""
import requests
import pandas as pd
import numpy as np
from datetime import date

BASE = "https://fxmacrodata.com/api/v1"
KEY  = "YOUR_API_KEY"
START = "2020-01-01"
THRESHOLD = 2
LOOKBACK  = 30
COST_BPS  = 5

def get(path: str) -> pd.DataFrame:
    r = requests.get(f"{BASE}{path}", params={"api_key": KEY, "start_date": START})
    r.raise_for_status()
    df = pd.DataFrame(r.json().get("data", []))
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date").sort_index()

# ── Fetch data ──
gold = get("/commodities/gold")[["val"]].rename(columns={"val": "gold"})

macro = {
    "tips":      (get("/announcements/usd/inflation_linked_bond"),  "negative"),
    "breakeven": (get("/announcements/usd/breakeven_inflation_rate"), "rising"),
    "policy":    (get("/announcements/usd/policy_rate"),             "falling"),
    "cb_assets": (get("/announcements/usd/cb_assets"),               "rising"),
    "m2":        (get("/announcements/usd/m2"),                      "rising"),
    "twi":       (get("/announcements/usd/trade_weighted_index"),    "falling"),
}

# ── Align and forward-fill ──
df = gold.copy()
for name, (series, _) in macro.items():
    s = series[["val"]].rename(columns={"val": name})
    df = df.join(s.reindex(df.index, method="ffill"))
df = df.dropna()

# ── Score ──
def score(col, mode):
    prev = col.shift(LOOKBACK)
    chg  = col - prev
    if mode == "negative":
        return col.apply(lambda v: 1 if v < 0 else (-1 if v > 1 else 0)).astype(float)
    if mode == "falling":
        return chg.apply(lambda c: 1 if c < -0.05 else (-1 if c > 0.05 else 0)).astype(float)
    if mode == "rising":
        return chg.apply(lambda c: 1 if c > 0.05 else (-1 if c < -0.05 else 0)).astype(float)
    return pd.Series(0.0, index=col.index)

df["net_score"] = sum(score(df[n], m) for n, (_, m) in macro.items())

# ── Trade ──
df["ret"] = df["gold"].pct_change()
df["pos"] = (df["net_score"] >= THRESHOLD).astype(float)
df["trade"] = df["pos"].diff().abs().fillna(0)
df["strat_ret"] = df["pos"].shift(1) * df["ret"] - df["trade"].shift(1) * (COST_BPS/1e4)
df["gold_cum"]  = (1 + df["ret"].fillna(0)).cumprod()
df["strat_cum"] = (1 + df["strat_ret"].fillna(0)).cumprod()

# ── Report ──
for label, cum_col, ret_col in [("Strategy", "strat_cum", "strat_ret"),
                                  ("Buy&Hold", "gold_cum", "ret")]:
    total = df[cum_col].iloc[-1] - 1
    vol   = df[ret_col].std() * np.sqrt(252)
    ann   = (1 + total) ** (252/len(df)) - 1
    sharpe = ann / vol if vol > 0 else 0
    peak  = df[cum_col].cummax()
    mdd   = ((df[cum_col] - peak) / peak).min()
    print(f"{label:12s}  Return: {total*100:+.1f}%  Sharpe: {sharpe:.2f}  MaxDD: {mdd*100:.1f}%")

print(f"\nDays invested: {df['pos'].mean()*100:.0f}%  |  Round-trips: {int(df['trade'].sum()/2)}")

Les principales conclusions et leçons pratiques

Des limites et des avertissements

• Un test de retour. Les résultats d'échantillons présentés dans cet article utilisent des données représentatives pour illustrer la méthodologie. Vous devez exécuter le script complet contre l'API en direct avec votre propre clé pour produire des résultats vérifiés sur votre plage de dates préférée.
• Bias de survie dans la sélection des indicateurs. Nous avons choisi ces six indicateurs parce qu'ils ont des antécédents théoriques solides pour l'or mais la sélection elle-même est une forme de corrélation implicite de la courbe.
• Pas de taille de position. L'approche binaire long/flat est délibérément simple. Une dimensionnement de position plus sophistiqué (par exemple, l'échelle de l'exposition par la magnitude du score net) pourrait améliorer les rendements ajustés au risque, mais ajoute des paramètres libres qui peuvent surpasser.
• Résultat en espèces ignoré. Dans la pratique, les taux à court terme ont été de 05,5% au cours de cette période , ce qui, si l'on inclut le rendement sans risque sur les liquidités inutilisées, améliorerait encore l'avantage ajusté du risque de la stratégie.
• Aucune modélisation des coûts de transaction pour les contrats à terme. Si l'opération est réalisée par l'intermédiaire de contrats à terme sur l'or plutôt que par l"intermédiation de FNB, les coûts de roulement et les exigences de marge s'appliquent.
• Décalage de publication des données macro. Le backtest utilise les dates de publication réelles il n'y a pas de biais de prospective. Mais dans le trading en direct, il peut y avoir quelques heures entre une publication de données et votre système le traitement.

Toutes les données utilisées dans ce backtest prix de l'or quotidiens et les six indicateurs macro américains sont disponibles à partir de l"API FXMacroData. point final de l'or en tant que produit de base Il fournit quotidiennement des prix fixes LBMA PM allant jusqu'en 2020. Endpoints macroéconomiques américains Les taux d'intérêt, l'inflation et les indicateurs monétaires sont couverts. Le code de l'information est le code de la personne concernée.Je suis désolé .