Backtesting der Gold-Makro-Scorecard: Liefert das Signal Ergebnisse?

Warum die Gold-Makro-Scorecard zurückprüfen?

In dem Begleitartikel Vorhersage der Goldpreise mit Makrodaten, haben wir eine zusammengesetzte Makro-Scorecard erstellt, die Richtungssignale für sechs US-Makro-Indikatoren zuweist TIPS 10Y Realrendite, Breakeven-Inflation, Fed-Policy-Rate, Fed Gesamtvermögen, M2 Geldmenge und der handelsgewichtete Dollar und aggregiert sie zu einer Netto-Gold-Vorsorge. Die Scorecard sagt Ihnen, ob das Makro regime Gold bevorzugt. Aber funktioniert es wirklich?

Dieser Artikel beantwortet diese Frage durch einen systematischen Backtest gegen täglich Goldpreise aus den FXMacroData Endpunkt für RohstoffeWir berechnen die Scorecard bei jeder Makrodatenveröffentlichung, halten eine einfache Long/Flat-Position in Gold auf der Grundlage des Netto-Signals und messen, ob dieses Signal eine sinnvolle Rendite über Buy-and-Hold liefert.

Schritt 1: Holen Sie sich tägliche Goldpreise und Makroserien

Die Basis des Backtests ist der tägliche Goldpreis aus den FXMacroData Rohstoffe/Gold Endpunkt LBMA PM Festpreise in USD pro Troy-Unze. Im Gegensatz zu monatlichen oder wöchentlichen aggregierten Daten lassen uns die täglichen Preise die genaue Auswirkung jedes Makro-Signalübergangs messen.

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

Als nächstes ziehen Sie die sechs Makroindikatorserien, die die Scorecard speisen, heraus. Diese werden mit unterschiedlicher Frequenz veröffentlicht einige wöchentlich (TIPS-Rendite, Breakeven), einige monatlich (CPI, M2), einige an FOMC-Daten (Policy Rate) , aber jede Beobachtung bleibt bis zur nächsten Veröffentlichung als "aktueller" Wert bestehen.

# 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()})")

Schritt 2: Ausrichtung der Reihenfolge und Vorfüllung

Alle Makroserien werden mit dem täglichen Golddatumsindex zusammengeführt. Jeder Makroverhalt wird vorzeitig ausgefüllt von seinem Veröffentlichungsdatum bis zur nächsten Veröffentlichtung vorgenommen , so dass der Backtest niemals zukünftige Informationen verwendet.

# 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())

Schritt 3: Berechnen Sie das tägliche Scorecard-Signal

An jedem Handelstag berechnen wir die gleiche Scorecard aus dem ursprünglichen Artikel , aber anstatt die letzten beiden Beobachtungen zu vergleichen, vergleiche ich den aktuellen vorab gefüllten Wert mit dem Wert von 30 Kalendertagen zuvor.

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))

Schritt 4: Definieren Sie die Handelsregeln

Der Backtest verwendet eine einfache, realistische Regel:

• Lange Signalzeit: Wenn die Netto-Scorecard ≥ +2 ist, gehen wir Long Gold (wir sind für Gold-Aufwertung positioniert).
• Flachsignal: Wenn die Netto-Scorecard < +2, halten Sie Bargeld (keine Goldposition).
• Keine Leerverkauf: Die Makro-Scorecard identifiziert günstige Regime für Gold sie erzeugt keine Kurzsignale für Gold mit der gleichen Sicherheit.
• Keine Hebelwirkung: Die Position ist entweder 100% Gold oder 100% Bargeld.
• Täglich wieder ausgleichen: Das Signal wird am Tagesabend bewertet; Positionsänderungen gelten für die Rendite des nächsten Handelstages.
• Transaktionskosten: Wir ziehen 5 Basispunkte pro Hin- und Rückhandel (Eingang + Ausgang) ab, um Spread und Slippage bei einem Gold-ETF oder Futures-Kontrakt zu berücksichtigen.

# 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}%")

Schritt 5: Leistungsmessung

Die Risikobereinigten Kennzahlen zeigen uns, ob die Überleistung der Strategie auf Geschicklichkeit (Zeitplanung des Makroresimils) oder einfach auf die Risikobereitschaft zurückzuführen ist.

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}")

Schritt 6: Analyse der Abzüge und Signalkwalität

Die wichtigste Wertvorstellung eines Makrotiming-Modells besteht nicht darin, jede Aufwärtsbewegung zu erfassen, sondern die schlimmsten Abwärtsschritte zu vermeiden.

# 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}%)")

Die Zinssenkung von 2022 ist das deutlichste Beispiel. Da die Fed die Zinsen von März bis Oktober 2022 aggressiv erhöhte, stieg die TIPS 10Y-Rendite von nahezu null auf +1,6%, der handelsgewichtete Dollar scharf an und das Wachstum von M2 wurde negativ. Die Scorecard las alle drei Signale korrekt als bärisch und wechselte in Bargeld, wodurch der Großteil des ~20%-Rückgangs von Gold von Spitze zu Tief vermieden wurde.

Schritt 7: Aufschlüsselung des Signalregimes

Die durchschnittliche Zinsrendite von Gold nach Netto-Score-Level wird aufgeschlüsselt, um zu ermitteln, wie das Signal zwischen günstigen und ungünstigen Regimes unterscheidet.

# 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))

Schritt 8: Überprüfung der Robustheit

Eine einzelne Backtest-Konfiguration kann übermäßig passen. Hier überprüfen wir, ob das Ergebnis nicht fragil ist, indem wir Schlüsselparameter variieren.

Grenzwerte für die Empfindlichkeit

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")

Rückblickende Empfindlichkeit

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}")

Schritt 9: Das komplette Backtest-Skript

Hier ist ein vollständiger, eigenständiger Backtest, der alle Daten von FXMacroData abruft, die Scorecard-Strategie ausführt und eine Leistungssummary mit einem grafisch vorbereiteten Output druckt.

"""
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)}")

Wichtige Erkenntnisse und praktische Lehren

Einschränkungen und Vorsichtsmaßnahmen

• Ein illustrativer Rücktest. Die in diesem Artikel gezeigten Beispielergebnisse verwenden repräsentative Daten, um die Methodik zu illustrieren.
• Überlebensverzerrung bei der Indikatorauswahl. Wir haben diese sechs Indikatoren ausgewählt, weil sie starke theoretische Vorurteile für Gold haben, aber die Auswahl selbst ist eine Form der impliziten Kurvenanpassung.
• Keine Positionsgröße. Die binäre Long/Flat-Ansatz ist absichtlich einfach. Eine anspruchsvollere Positionsgröße (z. B. Skalierung des Exposures nach Netto-Score-Größe) könnte die risikobereinigten Renditen verbessern, fügt aber freie Parameter hinzu, die möglicherweise übermäßig passen.
• Bargeldertrag ignoriert. In der Praxis betrugen die kurzfristigen Zinsen in diesem Zeitraum 05,5% , was die risikofreie Rendite von ungenutztem Bargeld mit einbezieht, die risikobereinigte Rentabilität der Strategie weiter verbessern würde.
• Keine Transaktionskostenmodellierung für Futures. Die Annahme von 5 Basispunkten für die Kosten für die Hin- und Rückreise ist repräsentativ für die Gold-ETF-Spreads, kann aber die Ausführungskosten für Futures unterschätzen.
• Verzögerung bei der Veröffentlichung von Makrodaten. Der Backtest verwendet die tatsächlichen Veröffentlichungsdaten es gibt keine Vorhersage. Aber im Live-Handel kann es einige Stunden zwischen einer Datenveröffentlichung und Ihrer Systemverarbeitung sein.

Alle Daten, die für diesen Backtest verwendet wurden tägliche Goldpreise und die sechs US-amerikanischen Makroindikatoren sind aus der FXMacroData API verfügbar. Endpunkt für Rohstoffgold Die LBMA PM liefert täglich Fixpreise bis 2020 und die US-amerikanische Makroendpunkte Die Datenbank enthält alle Zinssätze, Inflations- und Geldindikatoren. fxmacrodata.com/abonnieren- Ich weiß .