From 8732acf3d0311002c15c925a69c924d4291fd44c Mon Sep 17 00:00:00 2001 From: Tika Date: Sun, 8 Mar 2026 22:24:16 +0000 Subject: [PATCH] =?UTF-8?q?docs:=20plan=20Phase=204c=20CNN+Ensemble=20+=20?= =?UTF-8?q?mise=20=C3=A0=20jour=20PROJECT=5FSTATUS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Nouveau : docs/CNN_ENSEMBLE_PLAN.md — architecture complète CNN 1D + Ensemble pondéré + RL (Phase 4d) - PROJECT_STATUS : Phase 4b marquée avec fix bug SHORT LabelGenerator - PROJECT_STATUS : Phase 4c CNN+Ensemble et Phase 4d RL ajoutées Co-Authored-By: Claude Sonnet 4.6 --- docs/CNN_ENSEMBLE_PLAN.md | 227 ++++++++++++++++++++++++++++++++++++++ docs/PROJECT_STATUS.md | 28 ++++- 2 files changed, 254 insertions(+), 1 deletion(-) create mode 100644 docs/CNN_ENSEMBLE_PLAN.md diff --git a/docs/CNN_ENSEMBLE_PLAN.md b/docs/CNN_ENSEMBLE_PLAN.md new file mode 100644 index 0000000..02323ac --- /dev/null +++ b/docs/CNN_ENSEMBLE_PLAN.md @@ -0,0 +1,227 @@ +# Plan : CNN + Ensemble Multi-Signal + +**Créé** : 2026-03-08 +**Statut** : Phase 4c — En cours de développement + +--- + +## Concept + +Coupler trois modèles complémentaires pour produire un signal de trading robuste : + +``` +┌─────────────────────────────────────────────────────┐ +│ Signal final pondéré │ +│ trade si score > seuil (ex: 0.60) │ +│ │ +│ score = w1×XGB_conf + w2×CNN_conf (+ w3×RL_conf) │ +│ (ex: 0.40 × 0.72 + 0.60 × 0.68 = 0.70) │ +└──────────┬──────────────────────┬───────────────────┘ + │ │ + ┌──────▼──────┐ ┌──────▼──────┐ + │ XGBoost │ │ CNN │ + │ (Phase 4b) │ │ (Phase 4c) │ + │ │ │ │ + │ 50 features│ │ Fenêtre │ + │ TA calculés│ │ 64 bougies │ + │ (RSI, MACD,│ │ OHLCV → │ + │ pivots...)│ │ séquence │ + │ │ │ 1D CNN │ + │ "indicat." │ │ "visuel" │ + └─────────────┘ └─────────────┘ + │ (Phase 4d) + ┌──────▼──────┐ + │ RL │ + │ (futur) │ + │ Récompense │ + │ = PnL réel │ + │ Apprend par│ + │ essai/erreur│ + └─────────────┘ +``` + +### Complémentarité des modèles + +| Composant | Ce qu'il voit | Ce qu'il détecte | Limite | +|---|---|---|---| +| XGBoost | Indicateurs calculés | Combinaisons règles TA | Dépend des features choisies | +| CNN | Séquence brute OHLCV | Patterns visuels (double bottom, squeeze, H&S...) | Besoin de beaucoup de data | +| RL | Historique de ses trades | Ce qui rapporte sans règles | Instable, lent à converger | + +**Principe de l'ensemble** : un signal qui passe deux (ou trois) filtres indépendants a une probabilité nettement plus élevée d'être correct qu'un signal issu d'un seul modèle. + +--- + +## Phase 4c — CNN (priorité immédiate) + +### Architecture CNN + +``` +Entrée : dernières 64 bougies OHLCV + → normalisation z-score par fenêtre + → shape : (batch, 64, 5) # seq_len=64, features=5 (OHLCV) + +Conv1D(filters=32, kernel=3) → ReLU → MaxPool(2) +Conv1D(filters=64, kernel=3) → ReLU → MaxPool(2) +Conv1D(filters=128, kernel=3) → ReLU → GlobalAvgPool +Dense(128) → Dropout(0.3) +Dense(3) → Softmax # [LONG, SHORT, NEUTRAL] +``` + +Pas de conversion en image 2D — la CNN 1D sur séquences OHLCV est plus naturelle +et plus performante pour les séries temporelles financières. + +### Dépendance PyTorch + +Le CNN requiert PyTorch. Il faut : +1. Ajouter `torch==2.1.0+cpu` dans `docker/requirements/api.txt` + *(CPU only — pas de GPU requis pour l'inférence en trading)* +2. Rebuilder l'image : `docker compose build --no-cache trading-api` + +### Fichiers à créer — CNN + +``` +src/ml/cnn/ +├── __init__.py +├── candlestick_encoder.py # Normalisation + préparation séquences OHLCV +├── cnn_model.py # Architecture PyTorch (1D CNN) +└── cnn_strategy_model.py # Wrapper train/predict/save/load (comme MLStrategyModel) + +src/strategies/cnn_driven/ +├── __init__.py +└── cnn_strategy.py # CNNDrivenStrategy (hérite BaseStrategy) + +models/cnn_strategy/ # Sauvegardes .pt + _meta.json +``` + +### Routes API à ajouter — CNN + +| Méthode | Route | Description | +|---|---|---| +| POST | `/trading/train-cnn` | Lance entraînement CNN async | +| GET | `/trading/train-cnn/{job_id}` | Statut + métriques | +| GET | `/trading/cnn-models` | Liste modèles disponibles | + +### Métriques cibles CNN + +- `wf_accuracy > 0.52` (plus difficile que XGBoost — séquences brutes) +- Distribution LONG/SHORT équilibrée (même méthode labels que XGBoost) +- `wf_precision > 0.48` sur signaux directionnels + +--- + +## Phase 4c — Ensemble XGBoost + CNN + +### Logique de combinaison + +```python +# Les deux modèles prédisent indépendamment +xgb_result = xgb_model.predict(df) # {'signal': 1, 'confidence': 0.72} +cnn_result = cnn_model.predict(df) # {'signal': 1, 'confidence': 0.68} + +# Score pondéré (seulement si même direction) +if xgb_result['signal'] == cnn_result['signal']: + score = w_xgb * xgb_result['confidence'] + w_cnn * cnn_result['confidence'] + if score >= min_confidence: + → signal validé (beaucoup plus fiable) +else: + → NEUTRAL (désaccord entre modèles) +``` + +### Fichiers à créer — Ensemble + +``` +src/ml/ensemble/ +├── __init__.py +├── ensemble_model.py # Combine XGBoost + CNN (+ RL futur) +└── ensemble_config.py # Poids configurables par défaut + +src/strategies/ensemble/ +├── __init__.py +└── ensemble_strategy.py # EnsembleStrategy (hérite BaseStrategy) +``` + +### Routes API à ajouter — Ensemble + +| Méthode | Route | Description | +|---|---|---| +| POST | `/trading/ensemble/configure` | Définir les poids (xgb/cnn) | +| GET | `/trading/ensemble/signal` | Signal combiné en temps réel | +| GET | `/trading/ensemble/status` | Statut de chaque modèle de l'ensemble | + +### Configuration par défaut + +```json +{ + "weights": { + "xgboost": 0.40, + "cnn": 0.60 + }, + "min_confidence": 0.60, + "require_agreement": true +} +``` + +*Poids CNN légèrement supérieurs car il voit les patterns bruts sans nos biais de feature engineering.* + +--- + +## Phase 4d — RL (après 4c validée) + +Implémentation après validation CNN + Ensemble en paper trading (≥ 2 semaines). + +### Environnement RL + +``` +Framework : gymnasium (OpenAI Gym successor) +Algorithme : PPO (Proximal Policy Optimization) — stable et adapté au trading + +État : [dernières 64 bougies OHLCV + features XGBoost + signal CNN] +Action : {HOLD, LONG, SHORT, CLOSE} +Récompense : PnL réel net de frais, avec pénalité sur drawdown + +Entraînement : sur données historiques 3 ans (simulation) +Validation : walk-forward + paper trading +``` + +### Intégration dans l'ensemble + +```python +# Phase 4d : triplet +score = 0.30 * xgb_conf + 0.40 * cnn_conf + 0.30 * rl_conf +``` + +--- + +## TODO — Phase 4c (par ordre) + +### Étape 1 : Dépendance PyTorch +- [ ] Ajouter `torch==2.1.0+cpu` dans `docker/requirements/api.txt` +- [ ] Tester `docker compose build --no-cache trading-api` (peut prendre 10-15 min) + +### Étape 2 : CNN core +- [ ] `src/ml/cnn/candlestick_encoder.py` — normalisation z-score, padding, output shape (N, 64, 5) +- [ ] `src/ml/cnn/cnn_model.py` — architecture PyTorch, forward(), train_epoch(), eval_epoch() +- [ ] `src/ml/cnn/cnn_strategy_model.py` — train(), predict(), save(), load(), walk-forward eval + +### Étape 3 : CNN strategy + API +- [ ] `src/strategies/cnn_driven/cnn_strategy.py` — CNNDrivenStrategy +- [ ] Routes `POST /trading/train-cnn`, `GET /trading/train-cnn/{job_id}`, `GET /trading/cnn-models` + +### Étape 4 : Ensemble +- [ ] `src/ml/ensemble/ensemble_model.py` — combine XGBoost + CNN +- [ ] `src/strategies/ensemble/ensemble_strategy.py` — EnsembleStrategy +- [ ] Routes `/trading/ensemble/*` + +### Étape 5 : Validation +- [ ] Entraîner CNN sur EURUSD/1h (2 ans) +- [ ] Comparer backtest : Scalping vs XGBoost seul vs CNN seul vs Ensemble +- [ ] Si Ensemble Sharpe > 0.8, démarrer paper trading ensemble + +--- + +## Historique + +| Date | Version | Description | +|---|---|---| +| 2026-03-08 | v0.1 | Plan initial — architecture CNN + Ensemble + RL (futur) | diff --git a/docs/PROJECT_STATUS.md b/docs/PROJECT_STATUS.md index f36c5d2..e094cd4 100644 --- a/docs/PROJECT_STATUS.md +++ b/docs/PROJECT_STATUS.md @@ -110,7 +110,7 @@ Voir [docs/ML_STRATEGY_GUIDE.md](ML_STRATEGY_GUIDE.md) pour la documentation com | Composant | Fichier | Statut | |---|---|---| | TechnicalFeatureBuilder (~50 features) | `src/ml/features/technical_features.py` | ✅ | -| LabelGenerator (forward simulation) | `src/ml/features/label_generator.py` | ✅ | +| LabelGenerator (forward simulation) | `src/ml/features/label_generator.py` | ✅ fix bug SHORT (2026-03-08) | | MLStrategyModel (XGBoost/LightGBM) | `src/ml/ml_strategy_model.py` | ✅ | | MLDrivenStrategy (hérite BaseStrategy) | `src/strategies/ml_driven/ml_strategy.py` | ✅ | | Route POST /trading/train | `src/api/routers/trading.py` | ✅ | @@ -121,6 +121,32 @@ Voir [docs/ML_STRATEGY_GUIDE.md](ML_STRATEGY_GUIDE.md) pour la documentation com --- +## Phase 4c — CNN + Ensemble 🟡 (En cours) + +CNN 1D sur séquences brutes OHLCV + combinaison pondérée avec XGBoost. +Voir [docs/CNN_ENSEMBLE_PLAN.md](CNN_ENSEMBLE_PLAN.md) pour l'architecture complète. + +| Composant | Fichier | Statut | +|---|---|---| +| PyTorch CPU dans requirements | `docker/requirements/api.txt` | 🟡 | +| CandlestickEncoder (normalisation séquences) | `src/ml/cnn/candlestick_encoder.py` | 🟡 | +| CNNModel (1D Conv PyTorch) | `src/ml/cnn/cnn_model.py` | 🟡 | +| CNNStrategyModel (train/predict/save/load) | `src/ml/cnn/cnn_strategy_model.py` | 🟡 | +| CNNDrivenStrategy (hérite BaseStrategy) | `src/strategies/cnn_driven/cnn_strategy.py` | 🟡 | +| Routes API CNN (train, status, list) | `src/api/routers/trading.py` | 🟡 | +| EnsembleModel (XGBoost + CNN pondérés) | `src/ml/ensemble/ensemble_model.py` | 🟡 | +| EnsembleStrategy (hérite BaseStrategy) | `src/strategies/ensemble/ensemble_strategy.py` | 🟡 | +| Routes API Ensemble (configure, signal) | `src/api/routers/trading.py` | 🟡 | + +--- + +## Phase 4d — RL (Planifié, après 4c validée) + +Agent RL (PPO via gymnasium) intégré à l'ensemble comme troisième signal. +Voir [docs/CNN_ENSEMBLE_PLAN.md](CNN_ENSEMBLE_PLAN.md) section Phase 4d. + +--- + ## Routes API — État Complet | Méthode | Route | Statut |