From 9dc26ad48f17a72350d7af4ef848f6964c42a0d8 Mon Sep 17 00:00:00 2001 From: Axel Hocks Date: Mon, 27 Jul 2026 18:55:48 +0200 Subject: [PATCH] backtest_patterns.py + Circuit Breaker aus (User) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - backtest_patterns.py: misst die Chartmuster (echte patterns.py-Logik), 2 Halbjahre. Befund: ØR sieht positiv aus, aber Ziel-Trefferquote nur 13-38% → positiver R ist Trailing-Exit-Artefakt (Breakout+Trailing), KEIN Muster-Edge. Deckt sich mit backtest_doubletop (Ziel-Exit=negativ). Muster bleiben reine Anzeige; Kontrolle (generischer Breakout) fehlt noch fuer sauberen Beleg. - daily_loss_limit_pct=0 (Circuit Breaker auf User-Wunsch wieder deaktiviert). Co-Authored-By: Claude Opus 4.8 --- CLAUDE.md | 22 ++++- backtest_patterns.py | 199 +++++++++++++++++++++++++++++++++++++++++++ core/config.py | 2 +- 3 files changed, 219 insertions(+), 4 deletions(-) create mode 100644 backtest_patterns.py diff --git a/CLAUDE.md b/CLAUDE.md index 0f235c6..0aa5149 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -805,9 +805,11 @@ dort bereits nachvalidiert, ØR +0,305.) **Eine** Oberfläche: Heuristik-TF nur im Speicher (kein `save_config` mehr) — sonst würde die Secrets-`ini` bei jedem Switch neu geschrieben (Kommentar-Verlust/Churn). Beim Neustart wählt die Heuristik den TF binnen 1 min neu. -- **Circuit Breaker (Tagesverlust-Stopp) = AKTIV `[trading] daily_loss_limit_pct=8` - (User-Vorgabe 2026-07-27, im Rahmen des „Überlebens-Basis"-Pakets — vorher jahrelang - abgelehnt, mit dem Autonomie-Ziel reaktiviert):** erreicht der **Tages-P&L +- **Circuit Breaker (Tagesverlust-Stopp) = gebaut, aktuell AUS `[trading] + daily_loss_limit_pct=0` (User schaltete ihn am 2026-07-27 wenige Stunden nach dem + Einbau wieder ab). Kurz auf 8 aktiv (Überlebens-Basis, mit dem Autonomie-Ziel + reaktiviert nach jahrelanger Ablehnung), dann `=0`. Reaktivieren = ini auf z. B. 8.** + Mechanik bei `>0`: erreicht der **Tages-P&L (realisiert heute + offene Position)** −pct % der Balance, schließt der Bot die Position (`closed_by=circuit_breaker`) und sperrt **neue Auto-Trades bis zum nächsten Tag** (`_check_auto_squeeze` prüft `_circuit_halted()`). `_check_circuit_ @@ -1138,6 +1140,20 @@ dort bereits nachvalidiert, ØR +0,305.) **Eine** Oberfläche: IG, Axi): Umkehr (Doppel-, SKS, Rundung) vs. Fortsetzung (Dreieck, Flag, Tasse); Kursziel stets = Muster-Höhe ab Ausbruch projiziert — überall mit dem Caveat „keine Garantie, nur Indikation". + **Backtest gebaut & gemessen (`backtest_patterns.py`, 2026-07-27, 80k M30, 2 + Halbjahre, Einstieg beim Trigger-Bruch, Live-Exit+Echtkosten):** Mehrere Typen sehen + ØR-positiv in BEIDEN Hälften aus (Doppeltop +0,43/+0,23 · Tasse +0,35/+0,26 · inv. + Tasse +0,36/+0,58 · aufst. Dreieck +0,16/+0,10). ⚠ **ABER das ist ein Exit-Artefakt, + KEIN Muster-Edge:** die **Ziel-Trefferquote (Measured-Move vor SL) ist nur 13–38 %** + — die eigene Muster-Prognose trifft also in ~⅔ der Fälle NICHT. Der positive ØR + kommt vom **Trailing-Exit auf einem Momentum-Bruch** (Trigger-Bruch = Breakout, und + Breakout+Trailing hat generisch Edge — s. Squeeze), nicht von der Muster-Vorhersage. + Deckt sich mit `backtest_doubletop.py` (dort mit Ziel-/Fix-Exit → negativ) — der + Unterschied ist NUR der Exit. **Fazit: NICHT reif für Signal-Einfluss** — es fehlt + die Kontrolle „generischer Breakout + gleicher Exit" (isoliert den Muster-Beitrag, + wie Squeeze vs. beliebige Box); ohne die ist „Muster wirkt" nicht belegt. Muster + bleiben **reine Anzeige**. Ziel%-Spalte = der ehrliche Muster-Check (13–38 % = Muster + sagen den Kursverlauf kaum voraus). - **Kurslücken-Kachel** (`#card-gaps`): offene D1-Gaps des laufenden Jahres (`gaps.GapAnalyzer`, Refresh ~10 min im Trend-Loop unter `mt5_lock`). Je Gap: Richtung, Zone, Fill-Level, Abstand zum Kurs. Die **Fill-Level fließen als diff --git a/backtest_patterns.py b/backtest_patterns.py new file mode 100644 index 0000000..31d2b93 --- /dev/null +++ b/backtest_patterns.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Backtest der visuellen Chartmuster (Track B, Gate VOR Signal-Einfluss). + +Nutzt die ECHTE Erkennungslogik aus `core/patterns.py` (`_pivots` + dieselben +Toleranzen) → misst genau das, was die Dashboard-Karte zeigt. Ereignisbasiert: + + 1. Pivots auf der vollen M30-History (mit Bestätigungs-Lag k, KEIN Look-ahead). + 2. Jedes Muster-Vorkommen (Doppeltop/-boden, SKS/invers, Tasse/invers, Dreiecke) + an seinem FORMATIONS-Bar (letzter Pivot + k) mit Trigger/Ziel erfassen. + 3. Einstieg beim ersten Trigger-Bruch DANACH (in Musterrichtung, Fenster 48 Bars, + sonst verfällt das Muster = kein Trade). + 4. Exit = Live-Modell (SL 2,0×ATR + Trailing 1,5 + BE 1,3), Echtkosten (Bar- + Spread/ATR). Sequentiell (1 Position) → keine überlappenden Doppel-Trades. + 5. Auswertung je Muster-Typ, 2 Halbjahre: n / WR / ØR / PF / Ziel-Trefferquote. + +Einbau in die Empfehlung NUR, wenn ein Typ in BEIDEN Hälften ØR netto > ~+0,1×ATR +UND PF>1 zeigt (Squeeze-Maßstab). Erwartung niedrig — Muster-Klasse 2× verworfen. +""" +import sys +import MetaTrader5 as mt5 +from core.patterns import (_pivots, _PIVOT_K, _MIN_HEIGHT_ATR, _TOL_ATR, + _NECK_TOL_ATR) + +_MAXH = 288; _ATRMIN = 0.06; _BREAK_WIN = 48; _SL_ATR = 2.0; _TRAIL = 1.5 +_TRAIL_ON = 0.3; _BE = 1.3 + + +def _atr_series(H, L, C, p=14): + t = [0.0] + for i in range(1, len(C)): + t.append(max(H[i]-L[i], abs(H[i]-C[i-1]), abs(L[i]-C[i-1]))) + return [(sum(t[max(1, i-p+1):i+1])/max(1, len(t[max(1, i-p+1):i+1]))) if i else None + for i in range(len(C))] + + +def _sim(a, b, atr): + return max(0.0, 1.0 - abs(a-b)/(_TOL_ATR*atr)) if atr else 0.0 + + +def scan(P, A): + """→ Liste Muster-Events (form_bar, typ, dir, trigger, extreme). Nutzt dieselben + Bedingungen wie core.patterns._detect, aber über ALLE Pivot-Fenster der History.""" + ev = [] + K = _PIVOT_K + for a in range(len(P)-2): + (ia, pa, ka), (ib, pb, kb), (ic, pc, kc) = P[a], P[a+1], P[a+2] + fb = ic + K # Formations-Bar (letzter Pivot bestätigt) + if fb >= len(A) or not A[fb] or A[fb] <= 0: + continue + atr = max(A[fb], _ATRMIN) + def ok_h(ext, trig): return abs(ext-trig) >= _MIN_HEIGHT_ATR*atr + # Doppeltop H,L,H + if ka == "H" and kb == "L" and kc == "H": + if _sim(pa, pc, atr) > 0.35 and pb < min(pa, pc) and ok_h(max(pa, pc), pb): + ev.append((fb, "double_top", -1, pb, max(pa, pc))) + # Doppelboden L,H,L + if ka == "L" and kb == "H" and kc == "L": + if _sim(pa, pc, atr) > 0.35 and pb > max(pa, pc) and ok_h(min(pa, pc), pb): + ev.append((fb, "double_bottom", +1, pb, min(pa, pc))) + # (Inverse) Tasse+Henkel — Rand-Extrema ~gleich, breit (>=10 Bars) + span = ic - ia + if ka == "L" and kb == "H" and kc == "L" and span >= 10: + if _sim(pa, pc, atr) > 0.4 and pb > max(pa, pc) and ok_h(min(pa, pc), pb): + ev.append((fb, "inv_cup", -1, min(pa, pc), pb)) + if ka == "H" and kb == "L" and kc == "H" and span >= 10: + if _sim(pa, pc, atr) > 0.4 and pb < min(pa, pc) and ok_h(max(pa, pc), pb): + ev.append((fb, "cup", +1, max(pa, pc), pb)) + # Kopf-Schulter / inverse SKS (5 Pivots) + for a in range(len(P)-4): + w = P[a:a+5]; kinds = [x[2] for x in w]; pr = [x[1] for x in w] + fb = w[4][0] + K + if fb >= len(A) or not A[fb] or A[fb] <= 0: + continue + atr = max(A[fb], _ATRMIN) + if kinds == ["H", "L", "H", "L", "H"] and pr[2] > pr[0] and pr[2] > pr[4]: + neck = (pr[1]+pr[3])/2 + if _sim(pr[0], pr[4], atr)*_sim(pr[1], pr[3], atr) > 0.25 \ + and abs(pr[1]-pr[3]) < _NECK_TOL_ATR*atr and abs(pr[2]-neck) >= _MIN_HEIGHT_ATR*atr: + ev.append((fb, "hs", -1, neck, pr[2])) + if kinds == ["L", "H", "L", "H", "L"] and pr[2] < pr[0] and pr[2] < pr[4]: + neck = (pr[1]+pr[3])/2 + if _sim(pr[0], pr[4], atr)*_sim(pr[1], pr[3], atr) > 0.25 \ + and abs(pr[1]-pr[3]) < _NECK_TOL_ATR*atr and abs(pr[2]-neck) >= _MIN_HEIGHT_ATR*atr: + ev.append((fb, "inv_hs", +1, neck, pr[2])) + # Dreiecke (letzte 2 Hochs + 2 Tiefs bis zu jedem Pivot) + for a in range(3, len(P)): + sub = P[:a+1] + hs = [(x[0], x[1]) for x in sub if x[2] == "H"][-2:] + ls = [(x[0], x[1]) for x in sub if x[2] == "L"][-2:] + if len(hs) < 2 or len(ls) < 2: + continue + fb = P[a][0] + K + if fb >= len(A) or not A[fb] or A[fb] <= 0: + continue + atr = max(A[fb], _ATRMIN) + (_, h1), (_, h2) = hs; (_, l1), (_, l2) = ls + wide = abs(max(h1, h2)-min(l1, l2)) + if wide < _MIN_HEIGHT_ATR*atr: + continue + flat_h = abs(h2-h1) <= _NECK_TOL_ATR*atr; flat_l = abs(l2-l1) <= _NECK_TOL_ATR*atr + rising_l = l2 > l1+0.4*atr; falling_h = h2 < h1-0.4*atr + if flat_h and rising_l: + ev.append((fb, "tri_asc", +1, max(h1, h2), min(l1, l2))) + elif flat_l and falling_h: + ev.append((fb, "tri_desc", -1, min(l1, l2), max(h1, h2))) + ev.sort() + return ev + + +def sim(entry, d, atr, H, L, C, j0, target): + """Live-Exit (SL 2×ATR + Trailing) → (R, ziel_getroffen bool).""" + eff = entry - d*_SL_ATR*atr; hw = entry + end = min(j0+_MAXH, len(C)-1); exit_px = C[end]; hit = False + for j in range(j0, end+1): + hi, lo = H[j], L[j] + if (target is not None) and ((hi >= target) if d > 0 else (lo <= target)): + hit = True + if (lo <= eff) if d > 0 else (hi >= eff): + exit_px = eff; break + hw = max(hw, hi) if d > 0 else min(hw, lo) + prof = (C[j]-entry)*d + if prof >= _TRAIL_ON*atr: + cand = hw - d*_TRAIL*atr + if prof >= _BE*atr: cand = max(cand, entry) if d > 0 else min(cand, entry) + eff = max(eff, cand) if d > 0 else min(eff, cand) + return (exit_px-entry)*d/atr, hit + + +def rep(name, rows): + if not rows: + print(f" {name:<26} —"); return + R = [r[0] for r in rows]; n = len(R); w = sum(1 for x in R if x > 0) + up = sum(x for x in R if x > 0); dn = -sum(x for x in R if x < 0) + pf = up/dn if dn > 0 else 9.99; hit = 100*sum(1 for r in rows if r[1])/n + print(f" {name:<26} n={n:>4} WR={100*w/n:>3.0f}% ØR={sum(R)/n:+.3f} " + f"PF={pf:>4.2f} ΣR={sum(R):>+6.0f} Ziel={hit:>3.0f}%") + + +def run(H, L, C, SP, A, point, lo, hi): + """Sequentielle Sim über Events in [lo,hi). → dict typ→[(R,hit)].""" + P = _pivots(H, L, _PIVOT_K) + ev = [e for e in scan(P, A) if lo <= e[0] < hi] + def cost(i, atr): return (SP[i] if SP[i] > 0 else 0.0225)/atr + res = {}; next_free = lo + for fb, typ, d, trig, extreme in ev: + if fb < next_free: # überlappt laufenden Trade → skip + continue + entry_j = None + for j in range(fb+1, min(fb+1+_BREAK_WIN, len(C)-_MAXH-1)): + if (L[j] <= trig) if d < 0 else (H[j] >= trig): + entry_j = j; break + if entry_j is None: + continue + atr = max(A[entry_j] or 0, _ATRMIN) + h = abs(extreme-trig); target = trig - d*(-h) if False else (trig - h if d < 0 else trig + h) + r, hit = sim(trig, d, atr, H, L, C, entry_j+1, target) + r -= cost(entry_j, atr) + res.setdefault(typ, []).append((r, hit)) + next_free = None + # Exit-Bar approximieren: bis zum SL/MAXH; einfach _MAXH als Cooldown-Deckel + next_free = entry_j + 6 # kleiner Cooldown gegen Cluster + return res + + +def main(): + n = int(sys.argv[1]) if len(sys.argv) > 1 else 120000 + mt5.initialize() + sym = next((c for c in ("SpotCrude", "USOIL", "WTI", "XTIUSD") if mt5.symbol_info(c)), None) + bars = None + for req in (n, 100000, 80000, 60000, 40000): + bars = mt5.copy_rates_from_pos(sym, mt5.TIMEFRAME_M30, 0, req) + if bars is not None and len(bars) > 3000: + break + si = mt5.symbol_info(sym); point = si.point; mt5.shutdown() + H = [float(b["high"]) for b in bars]; L = [float(b["low"]) for b in bars] + C = [float(b["close"]) for b in bars]; SP = [float(b["spread"])*point for b in bars] + A = _atr_series(H, L, C); N = len(C); mid = N//2 + print("="*90) + print(f" Chartmuster-Backtest — {sym} M30 ({N} Bars) · Exit=live(SL2/Trail1,5/BE1,3) · Echtkosten") + print(f" Einbau NUR, wenn ein Typ in BEIDEN Hälften ØR>~+0,1 UND PF>1 (Muster-Klasse 2× verworfen)") + print("="*90) + types = ["double_top", "double_bottom", "hs", "inv_hs", "cup", "inv_cup", + "tri_asc", "tri_desc"] + label = {"double_top": "Doppeltop", "double_bottom": "Doppelboden", "hs": "Kopf-Schulter", + "inv_hs": "Inverse SKS", "cup": "Tasse+Henkel", "inv_cup": "Inv. Tasse+Henkel", + "tri_asc": "Aufst. Dreieck", "tri_desc": "Abst. Dreieck"} + for lbl, a, b in (("H1 (alt)", _PIVOT_K, mid), ("H2 (neu)", mid, N-_MAXH-1)): + res = run(H, L, C, SP, A, point, a, b) + allrows = [r for rows in res.values() for r in rows] + print(f"\n{lbl}:") + rep("ALLE Muster", allrows) + for t in types: + rep(label[t], res.get(t, [])) + print("\n ØR/PF je Typ in BEIDEN Hälften vergleichen. Ziel% = wie oft die Measured-Move-") + print(" Marke vor dem SL berührt wurde (Muster-Logik-Check, nicht der R-Ertrag).") + + +if __name__ == "__main__": + main() diff --git a/core/config.py b/core/config.py index 8a89cba..87451ca 100644 --- a/core/config.py +++ b/core/config.py @@ -277,7 +277,7 @@ DEFAULT_CONFIG = { # gegen Verlust-Kaskaden (früher abgelehnt, mit dem Autonomie-Ziel reaktiviert). # ⚠ Unter 80 %-Margin schützt es v. a. gegen die Serie, nicht den Einzeltrade. # 0 = aus. - "daily_loss_limit_pct": "8", + "daily_loss_limit_pct": "0", # Gewinn-mitnehmen automatisch beim Öffnen setzen (Kontowährung). 0 = aus # (dann nur manuell im UI). Merkt den zuletzt gesetzten Wert. "auto_takeprofit": "0",