#!/usr/bin/env python3 """ SPY Optimizer — HTML Report Generator ====================================== Génère un rapport HTML complet avec : - Résumé des performances du modèle IA - Walk-forward backtest par jour - Feature importance - Analyse par surge_type - Évolution des PnL dans le temps - Comparaison avec/sans filtre IA Usage: python generate_report.py # Rapport standard python generate_report.py --output report.html # Chemin personnalisé python generate_report.py --open # Ouvre dans le navigateur """ import argparse import json import sys from datetime import datetime, timezone from pathlib import Path import numpy as np import pandas as pd PROJECT_DIR = Path(__file__).parent DATA_DIR = PROJECT_DIR / "data" MODELS_DIR = PROJECT_DIR / "models" HISTORY_FILE = PROJECT_DIR.parent / "espion_history.json" OPTIMIZER_RESULTS = DATA_DIR / "optimizer_results.json" BACKTEST_RESULTS = DATA_DIR / "backtest_results.json" GPU_RESULTS = DATA_DIR / "gpu_optimization_results.json" DEFAULT_OUTPUT = PROJECT_DIR / "report.html" def load_data(): """Charge toutes les données disponibles.""" data = {} # Trades if HISTORY_FILE.exists(): with open(HISTORY_FILE) as f: all_trades = json.load(f) data["all_trades"] = all_trades START_DATE = "2026-04-01" data["trades"] = [t for t in all_trades if t.get("surge_type") and t.get("entry_time") and t["entry_time"][:10] >= START_DATE] else: data["all_trades"] = [] data["trades"] = [] # Résultats optimizer if OPTIMIZER_RESULTS.exists(): data["optimizer"] = json.loads(OPTIMIZER_RESULTS.read_text()) else: data["optimizer"] = None # Résultats backtest walk-forward if BACKTEST_RESULTS.exists(): data["backtest"] = json.loads(BACKTEST_RESULTS.read_text()) else: data["backtest"] = None # Résultats GPU (si disponibles) if GPU_RESULTS.exists(): data["gpu"] = json.loads(GPU_RESULTS.read_text()) else: data["gpu"] = None # Dataset features (si disponible) dataset_path = DATA_DIR / "training_dataset.parquet" if dataset_path.exists(): data["dataset"] = pd.read_parquet(dataset_path) else: data["dataset"] = None return data def compute_trade_stats(trades: list) -> dict: """Calcule les statistiques de trading.""" if not trades: return {} pnls = [float(t.get("pnl_usdt", 0)) for t in trades] pnl_pcts = [float(t.get("pnl_pct", 0)) for t in trades] profitable = [p for p in pnls if p > 0] losing = [p for p in pnls if p < 0] # Par surge_type by_type = {} for t in trades: st = t.get("surge_type", "UNKNOWN") if st not in by_type: by_type[st] = {"trades": [], "pnl": 0, "wins": 0} by_type[st]["trades"].append(t) pnl = float(t.get("pnl_usdt", 0)) by_type[st]["pnl"] += pnl if pnl > 0: by_type[st]["wins"] += 1 # Par jour (pour courbe) by_date = {} for t in trades: date = t.get("entry_time", "")[:10] if date not in by_date: by_date[date] = {"pnl": 0, "count": 0, "wins": 0} pnl = float(t.get("pnl_usdt", 0)) by_date[date]["pnl"] += pnl by_date[date]["count"] += 1 if pnl > 0: by_date[date]["wins"] += 1 # PnL cumulatif sorted_dates = sorted(by_date.keys()) cumulative = 0 cum_pnl = [] for d in sorted_dates: cumulative += by_date[d]["pnl"] cum_pnl.append({"date": d, "daily": round(by_date[d]["pnl"], 2), "cumulative": round(cumulative, 2), "count": by_date[d]["count"], "wins": by_date[d]["wins"]}) # Drawdown peak = 0 max_dd = 0 for p in cum_pnl: if p["cumulative"] > peak: peak = p["cumulative"] dd = peak - p["cumulative"] if dd > max_dd: max_dd = dd avg_win = sum(profitable) / len(profitable) if profitable else 0 avg_loss = sum(losing) / len(losing) if losing else 0 profit_factor = abs(sum(profitable) / sum(losing)) if losing and sum(losing) != 0 else float("inf") return { "total": len(trades), "wins": len(profitable), "losses": len(losing), "wr": len(profitable) / len(trades) * 100, "total_pnl": sum(pnls), "avg_pnl": sum(pnls) / len(pnls), "avg_win": avg_win, "avg_loss": avg_loss, "profit_factor": profit_factor, "best_trade": max(pnls), "worst_trade": min(pnls), "max_drawdown": max_dd, "by_type": by_type, "cum_pnl": cum_pnl, "period_start": min(t.get("entry_time", "")[:10] for t in trades), "period_end": max(t.get("entry_time", "")[:10] for t in trades), } def generate_html(data: dict, output: Path): """Génère le rapport HTML complet.""" now = datetime.now(timezone.utc).strftime("%d/%m/%Y %H:%M UTC") trades = data["trades"] stats = compute_trade_stats(trades) opt = data.get("optimizer", {}) or {} bt = data.get("backtest", {}) or {} gpu = data.get("gpu", {}) or {} dataset = data.get("dataset") metrics = opt.get("metrics", {}) bt_results = bt.get("results", {}) bt_windows = bt_results.get("window_details", []) # Feature importance depuis dataset feature_importance = {} if dataset is not None and "label" in dataset.columns: # Corrélation simple avec le label for col in dataset.columns: if col not in ("label", "entry_time", "symbol", "surge_type"): try: feature_importance[col] = abs(dataset[col].corr(dataset["label"])) except Exception: pass top_features = sorted(feature_importance.items(), key=lambda x: -x[1])[:15] # Stats par surge_type surge_rows = "" for st, s in sorted(stats.get("by_type", {}).items(), key=lambda x: -x[1]["pnl"]): n = len(s["trades"]) wr = s["wins"] / n * 100 color = "#27ae60" if s["pnl"] > 0 else "#e74c3c" surge_rows += f""" {st} {n} {wr:.1f}% ${s['pnl']:+.2f} ${s['pnl']/n:.2f} """ # Walk-forward rows wf_rows = "" for w in bt_windows: delta = w.get("pnl_with_filter", 0) - w.get("pnl_without_filter", 0) ok = "✅" if delta >= 0 else "❌" dcolor = "#27ae60" if delta >= 0 else "#e74c3c" wf_rows += f""" {w.get('val_date', '')} {w.get('n_trades', 0)} → {w.get('n_passed', 0)} {w.get('win_rate_filtered', 0):.1f}% {w.get('pnl_without_filter', 0):+.1f}% {w.get('pnl_with_filter', 0):+.1f}% {delta:+.1f}% {ok} {w.get('threshold', 0):.2f} """ # Données pour graphiques Chart.js cum_labels = [d["date"] for d in stats.get("cum_pnl", [])] cum_values = [d["cumulative"] for d in stats.get("cum_pnl", [])] daily_values = [d["daily"] for d in stats.get("cum_pnl", [])] daily_counts = [d["count"] for d in stats.get("cum_pnl", [])] daily_wr = [round(d["wins"]/d["count"]*100, 1) for d in stats.get("cum_pnl", []) if d["count"] > 0] # Données backtest pour graphique bt_labels = [w.get("val_date", "") for w in bt_windows] bt_with = [w.get("pnl_with_filter", 0) for w in bt_windows] bt_without = [w.get("pnl_without_filter", 0) for w in bt_windows] # Feature importance pour graphique fi_labels = [f[0] for f in top_features] fi_values = [round(f[1], 4) for f in top_features] # GPU info gpu_section = "" if gpu: gpu_metrics = gpu.get("best_params", gpu.get("metrics", {})) gpu_device = gpu.get("device", "N/A") gpu_trials = gpu.get("n_trials", "N/A") gpu_auc = gpu.get("best_auc", gpu.get("auc_roc", "N/A")) gpu_section = f"""
🎮

Optimisation GPU

PC Training
Device {gpu_device}
Trials Optuna {gpu_trials}
Best AUC {gpu_auc if isinstance(gpu_auc, str) else f'{gpu_auc:.4f}'}
""" wr = stats.get("wr", 0) total_pnl = stats.get("total_pnl", 0) model_auc = metrics.get("auc_roc", 0) model_acc = metrics.get("accuracy", 0) * 100 trade_rate = metrics.get("trade_rate", 1) * 100 pnl_improvement = metrics.get("pnl_improvement", bt_results.get("pnl_improvement", 0)) bt_positive_windows = bt_results.get("positive_windows_pct", 0) html = f""" Trading Apple IA — Rapport SPY Optimizer

Trading Apple IATrading Apple IA — SPY Optimizer Report

Analyse complète des performances du Signal Classifier IA

Généré le {now}
Période: {stats.get('period_start','N/A')} → {stats.get('period_end','N/A')}

🔐 Connexion requise

Entrez vos identifiants du dashboard pour contrôler le pipeline GPU

PnL Total
${total_pnl:+.0f}
USDT net
Win Rate
{wr:.1f}%
{stats.get('wins', 0)}/{stats.get('total', 0)} trades
AUC-ROC (IA)
{model_auc:.3f}
Discriminant du modèle
Accuracy IA
{model_acc:.1f}%
Validation temporelle
Impact Filtre IA
{pnl_improvement:+.1f}%
vs sans filtre
Profit Factor
{min(stats.get('profit_factor', 0), 9.99):.2f}
Gains / Pertes abs.
{'
ℹ️ Modèle entraîné localement (CPU) — Pour activer l\'optimisation GPU, lancez connect_tunnel.ps1 sur votre PC puis python remote_gpu_train.py
' if not gpu else '
✅ Modèle optimisé GPU — Le PC Windows a participé à l\'entraînement
'}
📈

PnL Cumulatif

${total_pnl:+.2f} USDT
📊

PnL Journalier

{len(stats.get('cum_pnl', []))} jours
🤖

Modèle IA — Signal Classifier

LightGBM + XGBoost
AUC-ROC
{model_auc:.4f}
Accuracy
{model_acc:.1f}%
Precision
{metrics.get('precision', 0)*100:.1f}%
Recall
{metrics.get('recall', 0)*100:.1f}%
F1-Score
{metrics.get('f1', 0):.3f}
Trade Rate
{trade_rate:.0f}%
Dataset
{opt.get('dataset_size', 0)}
WR filtré
{metrics.get('win_rate_filtered', 0):.1f}%
PnL Sans filtre vs Avec filtre IA
Sans filtre: {metrics.get('pnl_without_filter', 0):+.1f}% → Avec filtre: {metrics.get('pnl_with_filter', 0):+.1f}% ({pnl_improvement:+.1f}%)
⏱️

Walk-Forward Backtest

{bt_positive_windows:.0f}% positifs
🔑

Feature Importance (Top 15)

📋

Détail Walk-Forward

{len(bt_windows)} fenêtres
{wf_rows}
Date Trades WR Sans IA Avec IA Δ Seuil
Total: {bt_results.get('total_trades', 0)} trades → {bt_results.get('total_passed', 0)} passés PnL global: {bt_results.get('pnl_improvement', 0):+.2f}%
⚡

Performance par Surge Type

{len(stats.get('by_type', {}))} types
{surge_rows}
Surge Type Trades Win Rate PnL Total PnL Moyen
💰

Statistiques de Trading

{stats.get('period_start','?')} → {stats.get('period_end','?')}
Total Trades
{stats.get('total', 0)}
Win Rate
{wr:.1f}%
PnL Total
${total_pnl:+.2f}
PnL Moyen
${stats.get('avg_pnl', 0):+.2f}
Gain Moyen
${stats.get('avg_win', 0):+.2f}
Perte Moyenne
${stats.get('avg_loss', 0):+.2f}
Meilleur Trade
${stats.get('best_trade', 0):+.2f}
Pire Trade
${stats.get('worst_trade', 0):+.2f}
Profit Factor
{min(stats.get('profit_factor', 0), 9.99):.2f}
Max Drawdown
-${stats.get('max_drawdown', 0):.2f}
{gpu_section}
🤖 SPY Optimizer
Statut pipeline
En attente
📊 Progression du pipeline
1
Téléchgt
klines 1m
2
Dataset
Features
3
GPU
Optuna
4
Walk-Fwd
Backtest
5
Rapport
HTML
✓
Déploie-
ment

📈 Dernière analyse GPU

AUC-ROC
{model_auc:.4f}
Accuracy
{model_acc:.1f}%
Win Rate filtré
{metrics.get('win_rate_filtered',0):.1f}%
Impact IA
{pnl_improvement:+.2f}%
Trades analysés
{stats.get('total',0)}
Période
{stats.get('period_start','?')} → {stats.get('period_end','?')}
Trading Apple IA — SPY Optimizer Report • Généré le {now} • LightGBM + XGBoost + Optuna
""" output.write_text(html, encoding="utf-8") print(f" ✅ Rapport généré: {output}") print(f" Taille: {output.stat().st_size / 1024:.1f} KB") return output def main(): parser = argparse.ArgumentParser(description="SPY Optimizer — HTML Report Generator") parser.add_argument("--output", type=str, default=str(DEFAULT_OUTPUT), help="Chemin du fichier HTML") parser.add_argument("--open", action="store_true", help="Ouvrir dans le navigateur") args = parser.parse_args() output = Path(args.output) print(f"\n{'='*60}") print(f" 📊 SPY Optimizer — Génération du rapport HTML") print(f"{'='*60}") print(f" 📂 Chargement des données...") data = load_data() trades = data["trades"] print(f" {len(trades)} trades exploitables") if data["optimizer"]: print(f" ✅ Résultats optimizer chargés ({data['optimizer'].get('timestamp','')[:10]})") if data["backtest"]: bw = data["backtest"].get("results", {}).get("windows", 0) print(f" ✅ Walk-forward backtest chargé ({bw} fenêtres)") if data["gpu"]: print(f" ✅ Résultats GPU chargés") if data["dataset"] is not None: print(f" ✅ Dataset features: {len(data['dataset'])} samples × {len(data['dataset'].columns)} colonnes") print(f"\n ⚙️ Génération du HTML...") generate_html(data, output) if args.open: import webbrowser webbrowser.open(f"file://{output.resolve()}") print(f"\n 📁 Rapport disponible sur:") print(f" Local: {output}") print(f" Web: https://trading-pascal.duckdns.org/spy_report.html") print(f"\n 💡 Pour servir le rapport via le dashboard:") print(f" cp {output} /home/ubuntu/crypto_trading_bot/spy_report.html") print(f"{'='*60}") if __name__ == "__main__": main()