Initial commit — Trading AI Secure project complet
Architecture Docker (8 services), FastAPI, TimescaleDB, Redis, Streamlit. Stratégies : scalping, intraday, swing. MLEngine + RegimeDetector (HMM). BacktestEngine + WalkForwardAnalyzer + Optuna optimizer. Routes API complètes dont /optimize async. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Tika
575
docs/ARCHITECTURE.md
Normal file
575
docs/ARCHITECTURE.md
Normal file
@@ -0,0 +1,575 @@
|
||||
# 🏗️ Architecture Détaillée - Trading AI Secure
|
||||
|
||||
## 📋 Table des Matières
|
||||
1. [Vue d'ensemble](#vue-densemble)
|
||||
2. [Architecture Globale](#architecture-globale)
|
||||
3. [Modules Core](#modules-core)
|
||||
4. [Flux de Données](#flux-de-données)
|
||||
5. [Patterns et Principes](#patterns-et-principes)
|
||||
6. [Sécurité](#sécurité)
|
||||
7. [Scalabilité](#scalabilité)
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Vue d'ensemble
|
||||
|
||||
### Principes Architecturaux
|
||||
|
||||
1. **Separation of Concerns** : Chaque module a une responsabilité unique
|
||||
2. **Dependency Injection** : Facilite tests et modularité
|
||||
3. **Event-Driven** : Communication asynchrone entre composants
|
||||
4. **Fail-Safe** : Dégradation gracieuse en cas d'erreur
|
||||
5. **Observable** : Monitoring et logging à tous les niveaux
|
||||
|
||||
### Stack Technologique
|
||||
|
||||
```yaml
|
||||
Backend:
|
||||
Language: Python 3.11+
|
||||
Framework: FastAPI
|
||||
Async: asyncio + threading
|
||||
|
||||
Data:
|
||||
Storage: PostgreSQL (positions, trades)
|
||||
Cache: Redis (market data, signals)
|
||||
Time-Series: InfluxDB (métriques)
|
||||
|
||||
ML/AI:
|
||||
Core: scikit-learn, XGBoost, LightGBM
|
||||
Optimization: Optuna
|
||||
Deep Learning: TensorFlow/PyTorch (optionnel)
|
||||
|
||||
Monitoring:
|
||||
Metrics: Prometheus
|
||||
Visualization: Grafana
|
||||
Logging: ELK Stack (Elasticsearch, Logstash, Kibana)
|
||||
|
||||
UI:
|
||||
Dashboard: Streamlit
|
||||
API Docs: Swagger/OpenAPI
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🏛️ Architecture Globale
|
||||
|
||||
### Diagramme de Haut Niveau
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────┐
|
||||
│ TRADING AI SECURE │
|
||||
├─────────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||||
│ │ UI LAYER │ │ API LAYER │ │ MONITORING │ │
|
||||
│ │ │ │ │ │ │ │
|
||||
│ │ Streamlit │ │ FastAPI │ │ Prometheus │ │
|
||||
│ │ Dashboard │ │ REST API │ │ Grafana │ │
|
||||
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
|
||||
│ │ │ │ │
|
||||
│ └─────────────────┼─────────────────┘ │
|
||||
│ │ │
|
||||
│ ┌────────────────────────▼────────────────────────┐ │
|
||||
│ │ ORCHESTRATION LAYER │ │
|
||||
│ │ │ │
|
||||
│ │ ┌──────────────┐ ┌──────────────┐ │ │
|
||||
│ │ │ Strategy │ │ Risk │ │ │
|
||||
│ │ │ Engine │ │ Manager │ │ │
|
||||
│ │ │ (Singleton) │ │ (Singleton) │ │ │
|
||||
│ │ └──────┬───────┘ └──────┬───────┘ │ │
|
||||
│ │ │ │ │ │
|
||||
│ │ └────────┬────────┘ │ │
|
||||
│ │ │ │ │
|
||||
│ └──────────────────┼──────────────────────────────┘ │
|
||||
│ │ │
|
||||
│ ┌──────────────────▼──────────────────────────────┐ │
|
||||
│ │ CORE SERVICES │ │
|
||||
│ │ │ │
|
||||
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
|
||||
│ │ │ Data │ │ ML │ │ Order │ │ │
|
||||
│ │ │ Service │ │ Engine │ │ Manager │ │ │
|
||||
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
|
||||
│ │ │ │ │ │ │
|
||||
│ └───────┼─────────────┼─────────────┼─────────────┘ │
|
||||
│ │ │ │ │
|
||||
│ ┌───────▼─────────────▼─────────────▼─────────────┐ │
|
||||
│ │ DATA & INTEGRATION LAYER │ │
|
||||
│ │ │ │
|
||||
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
|
||||
│ │ │ Market │ │ IG │ │ Cache │ │ │
|
||||
│ │ │ Data │ │ API │ │ (Redis) │ │ │
|
||||
│ │ │ Sources │ │Connector │ │ │ │ │
|
||||
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
|
||||
│ │ │ │
|
||||
│ └──────────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
│ ┌──────────────────────────────────────────────────┐ │
|
||||
│ │ PERSISTENCE LAYER │ │
|
||||
│ │ │ │
|
||||
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
|
||||
│ │ │PostgreSQL│ │ InfluxDB │ │ File │ │ │
|
||||
│ │ │(Trades, │ │(Metrics, │ │ System │ │ │
|
||||
│ │ │Positions)│ │TimeSeries│ │ (Logs) │ │ │
|
||||
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
|
||||
│ └──────────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔧 Modules Core
|
||||
|
||||
### 1. Strategy Engine
|
||||
|
||||
**Responsabilité** : Orchestration des stratégies de trading
|
||||
|
||||
```python
|
||||
# src/core/strategy_engine.py
|
||||
|
||||
class StrategyEngine:
|
||||
"""
|
||||
Moteur central de gestion des stratégies
|
||||
|
||||
Responsabilités:
|
||||
- Charger et initialiser stratégies
|
||||
- Distribuer données marché
|
||||
- Collecter signaux
|
||||
- Coordonner exécution
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.strategies: Dict[str, BaseStrategy] = {}
|
||||
self.active_signals: List[Signal] = []
|
||||
self.risk_manager = RiskManager()
|
||||
self.order_manager = OrderManager()
|
||||
|
||||
async def run(self):
|
||||
"""Boucle principale"""
|
||||
while True:
|
||||
# 1. Récupérer données marché
|
||||
market_data = await self.fetch_market_data()
|
||||
|
||||
# 2. Analyser avec chaque stratégie
|
||||
signals = await self.analyze_strategies(market_data)
|
||||
|
||||
# 3. Filtrer avec risk manager
|
||||
valid_signals = self.risk_manager.filter_signals(signals)
|
||||
|
||||
# 4. Exécuter signaux valides
|
||||
await self.execute_signals(valid_signals)
|
||||
|
||||
# 5. Mettre à jour positions
|
||||
await self.update_positions()
|
||||
|
||||
# 6. Sleep jusqu'à prochaine itération
|
||||
await asyncio.sleep(self.interval)
|
||||
```
|
||||
|
||||
### 2. Risk Manager (Singleton)
|
||||
|
||||
**Responsabilité** : Gestion centralisée du risque
|
||||
|
||||
```python
|
||||
# src/core/risk_manager.py
|
||||
|
||||
class RiskManager:
|
||||
"""
|
||||
Singleton Risk Manager
|
||||
|
||||
Garantit:
|
||||
- Une seule instance
|
||||
- État global cohérent
|
||||
- Thread-safe
|
||||
"""
|
||||
|
||||
_instance = None
|
||||
_lock = threading.Lock()
|
||||
|
||||
def __new__(cls):
|
||||
if cls._instance is None:
|
||||
with cls._lock:
|
||||
if cls._instance is None:
|
||||
cls._instance = super().__new__(cls)
|
||||
return cls._instance
|
||||
|
||||
def __init__(self):
|
||||
if not hasattr(self, 'initialized'):
|
||||
self.initialized = True
|
||||
self.positions = {}
|
||||
self.portfolio_value = 0.0
|
||||
self.peak_value = 0.0
|
||||
# ... autres attributs
|
||||
```
|
||||
|
||||
### 3. Data Service
|
||||
|
||||
**Responsabilité** : Abstraction des sources de données
|
||||
|
||||
```python
|
||||
# src/data/data_service.py
|
||||
|
||||
class DataService:
|
||||
"""
|
||||
Service unifié d'accès aux données
|
||||
|
||||
Features:
|
||||
- Multi-source avec failover
|
||||
- Cache intelligent
|
||||
- Validation données
|
||||
- Rate limiting
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.sources = self._initialize_sources()
|
||||
self.cache = RedisCache()
|
||||
self.validator = DataValidator()
|
||||
|
||||
async def get_market_data(
|
||||
self,
|
||||
symbol: str,
|
||||
timeframe: str,
|
||||
start: datetime,
|
||||
end: datetime
|
||||
) -> pd.DataFrame:
|
||||
"""
|
||||
Récupère données marché avec failover
|
||||
"""
|
||||
# 1. Check cache
|
||||
cached = await self.cache.get(symbol, timeframe, start, end)
|
||||
if cached:
|
||||
return cached
|
||||
|
||||
# 2. Essayer sources par priorité
|
||||
for source in self.sources:
|
||||
try:
|
||||
data = await source.fetch(symbol, timeframe, start, end)
|
||||
|
||||
# 3. Valider
|
||||
if self.validator.validate(data):
|
||||
# 4. Cache
|
||||
await self.cache.set(symbol, timeframe, data)
|
||||
return data
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Source {source.name} failed: {e}")
|
||||
continue
|
||||
|
||||
raise DataUnavailableError("All sources failed")
|
||||
```
|
||||
|
||||
### 4. ML Engine
|
||||
|
||||
**Responsabilité** : Intelligence artificielle adaptative
|
||||
|
||||
```python
|
||||
# src/ml/ml_engine.py
|
||||
|
||||
class MLEngine:
|
||||
"""
|
||||
Moteur ML adaptatif
|
||||
|
||||
Features:
|
||||
- Ensemble de modèles
|
||||
- Auto-retraining
|
||||
- Parameter optimization
|
||||
- Regime detection
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.models = self._initialize_models()
|
||||
self.optimizer = OptunaOptimizer()
|
||||
self.regime_detector = RegimeDetector()
|
||||
|
||||
async def predict(self, features: pd.DataFrame) -> Dict:
|
||||
"""
|
||||
Prédiction avec ensemble
|
||||
"""
|
||||
# 1. Détecter régime
|
||||
regime = self.regime_detector.detect(features)
|
||||
|
||||
# 2. Sélectionner modèles selon régime
|
||||
active_models = self._select_models(regime)
|
||||
|
||||
# 3. Prédictions individuelles
|
||||
predictions = []
|
||||
for model in active_models:
|
||||
pred = model.predict(features)
|
||||
predictions.append(pred)
|
||||
|
||||
# 4. Agrégation (stacking)
|
||||
final_prediction = self._aggregate(predictions)
|
||||
|
||||
return {
|
||||
'prediction': final_prediction,
|
||||
'confidence': self._calculate_confidence(predictions),
|
||||
'regime': regime
|
||||
}
|
||||
|
||||
async def optimize_daily(self):
|
||||
"""
|
||||
Optimisation quotidienne des paramètres
|
||||
"""
|
||||
# 1. Récupérer performance récente
|
||||
recent_performance = self._get_recent_performance()
|
||||
|
||||
# 2. Détecter drift
|
||||
if self._detect_drift(recent_performance):
|
||||
# 3. Lancer optimisation Optuna
|
||||
new_params = await self.optimizer.optimize()
|
||||
|
||||
# 4. Valider avec backtesting
|
||||
if self._validate_params(new_params):
|
||||
# 5. Appliquer nouveaux paramètres
|
||||
self._update_parameters(new_params)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔄 Flux de Données
|
||||
|
||||
### Flux Principal (Trading Loop)
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ TRADING LOOP (60s) │
|
||||
├─────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ 1. FETCH MARKET DATA │
|
||||
│ ├─ Check cache │
|
||||
│ ├─ Fetch from sources (failover) │
|
||||
│ └─ Validate & store │
|
||||
│ │
|
||||
│ 2. ANALYZE STRATEGIES │
|
||||
│ ├─ Calculate indicators │
|
||||
│ ├─ ML predictions │
|
||||
│ ├─ Generate signals │
|
||||
│ └─ Calculate confidence │
|
||||
│ │
|
||||
│ 3. RISK VALIDATION │
|
||||
│ ├─ Check portfolio risk │
|
||||
│ ├─ Validate position size │
|
||||
│ ├─ Check correlation │
|
||||
│ ├─ Verify margin │
|
||||
│ └─ Circuit breakers │
|
||||
│ │
|
||||
│ 4. ORDER EXECUTION │
|
||||
│ ├─ Place orders (IG API) │
|
||||
│ ├─ Confirm execution │
|
||||
│ └─ Update positions │
|
||||
│ │
|
||||
│ 5. MONITORING │
|
||||
│ ├─ Update metrics │
|
||||
│ ├─ Check alerts │
|
||||
│ └─ Log events │
|
||||
│ │
|
||||
│ 6. SLEEP (until next iteration) │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
### Flux Optimisation (Daily)
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ OPTIMIZATION LOOP (Daily 00:00) │
|
||||
├─────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ 1. COLLECT PERFORMANCE DATA │
|
||||
│ ├─ Last 30 days trades │
|
||||
│ ├─ Calculate metrics │
|
||||
│ └─ Detect drift │
|
||||
│ │
|
||||
│ 2. PARAMETER OPTIMIZATION (if drift detected) │
|
||||
│ ├─ Define search space │
|
||||
│ ├─ Run Optuna (Bayesian) │
|
||||
│ ├─ Backtest candidates │
|
||||
│ └─ Select best parameters │
|
||||
│ │
|
||||
│ 3. VALIDATION │
|
||||
│ ├─ Walk-forward analysis │
|
||||
│ ├─ Monte Carlo simulation │
|
||||
│ └─ Out-of-sample test │
|
||||
│ │
|
||||
│ 4. A/B TESTING │
|
||||
│ ├─ Deploy variant in paper trading │
|
||||
│ ├─ Monitor 7 days │
|
||||
│ └─ Compare vs control │
|
||||
│ │
|
||||
│ 5. DEPLOYMENT (if validated) │
|
||||
│ ├─ Update strategy parameters │
|
||||
│ ├─ Retrain ML models │
|
||||
│ └─ Notify operators │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎨 Patterns et Principes
|
||||
|
||||
### Design Patterns Utilisés
|
||||
|
||||
#### 1. Singleton (Risk Manager)
|
||||
|
||||
```python
|
||||
class RiskManager:
|
||||
_instance = None
|
||||
_lock = threading.Lock()
|
||||
|
||||
def __new__(cls):
|
||||
if cls._instance is None:
|
||||
with cls._lock:
|
||||
if cls._instance is None:
|
||||
cls._instance = super().__new__(cls)
|
||||
return cls._instance
|
||||
```
|
||||
|
||||
**Pourquoi** : Garantir une seule instance pour état global cohérent
|
||||
|
||||
#### 2. Strategy Pattern (Stratégies de Trading)
|
||||
|
||||
```python
|
||||
class BaseStrategy(ABC):
|
||||
@abstractmethod
|
||||
def analyze(self, data):
|
||||
pass
|
||||
|
||||
class ScalpingStrategy(BaseStrategy):
|
||||
def analyze(self, data):
|
||||
# Implémentation scalping
|
||||
pass
|
||||
|
||||
class IntradayStrategy(BaseStrategy):
|
||||
def analyze(self, data):
|
||||
# Implémentation intraday
|
||||
pass
|
||||
```
|
||||
|
||||
**Pourquoi** : Facilite ajout de nouvelles stratégies
|
||||
|
||||
#### 3. Observer Pattern (Events)
|
||||
|
||||
```python
|
||||
class EventBus:
|
||||
def __init__(self):
|
||||
self.subscribers = {}
|
||||
|
||||
def subscribe(self, event_type, callback):
|
||||
if event_type not in self.subscribers:
|
||||
self.subscribers[event_type] = []
|
||||
self.subscribers[event_type].append(callback)
|
||||
|
||||
def publish(self, event_type, data):
|
||||
for callback in self.subscribers.get(event_type, []):
|
||||
callback(data)
|
||||
|
||||
# Usage
|
||||
event_bus.subscribe('trade_executed', log_trade)
|
||||
event_bus.subscribe('trade_executed', update_metrics)
|
||||
event_bus.publish('trade_executed', trade_data)
|
||||
```
|
||||
|
||||
**Pourquoi** : Découplage entre composants
|
||||
|
||||
#### 4. Factory Pattern (Création Stratégies)
|
||||
|
||||
```python
|
||||
class StrategyFactory:
|
||||
@staticmethod
|
||||
def create(strategy_type: str, config: Dict) -> BaseStrategy:
|
||||
if strategy_type == 'scalping':
|
||||
return ScalpingStrategy(config)
|
||||
elif strategy_type == 'intraday':
|
||||
return IntradayStrategy(config)
|
||||
elif strategy_type == 'swing':
|
||||
return SwingStrategy(config)
|
||||
else:
|
||||
raise ValueError(f"Unknown strategy: {strategy_type}")
|
||||
```
|
||||
|
||||
**Pourquoi** : Centralise logique de création
|
||||
|
||||
### Principes SOLID
|
||||
|
||||
- **S**ingle Responsibility : Chaque classe une responsabilité
|
||||
- **O**pen/Closed : Ouvert extension, fermé modification
|
||||
- **L**iskov Substitution : Sous-classes substituables
|
||||
- **I**nterface Segregation : Interfaces spécifiques
|
||||
- **D**ependency Inversion : Dépendre d'abstractions
|
||||
|
||||
---
|
||||
|
||||
## 🔒 Sécurité
|
||||
|
||||
### Niveaux de Sécurité
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ SECURITY LAYERS │
|
||||
├─────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ LAYER 1: Authentication & Authorization │
|
||||
│ ├─ API Key management │
|
||||
│ ├─ OAuth 2.0 (IG Markets) │
|
||||
│ └─ Role-based access control │
|
||||
│ │
|
||||
│ LAYER 2: Data Encryption │
|
||||
│ ├─ Credentials encrypted at rest │
|
||||
│ ├─ TLS/SSL for API calls │
|
||||
│ └─ Database encryption │
|
||||
│ │
|
||||
│ LAYER 3: Input Validation │
|
||||
│ ├─ Pydantic models │
|
||||
│ ├─ SQL injection prevention │
|
||||
│ └─ XSS protection │
|
||||
│ │
|
||||
│ LAYER 4: Rate Limiting │
|
||||
│ ├─ API rate limiting │
|
||||
│ ├─ Brute force protection │
|
||||
│ └─ DDoS mitigation │
|
||||
│ │
|
||||
│ LAYER 5: Audit & Monitoring │
|
||||
│ ├─ All actions logged │
|
||||
│ ├─ Anomaly detection │
|
||||
│ └─ Security alerts │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📈 Scalabilité
|
||||
|
||||
### Stratégies de Scaling
|
||||
|
||||
#### Horizontal Scaling
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ HORIZONTAL SCALING STRATEGY │
|
||||
├─────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ Load Balancer │
|
||||
│ │ │
|
||||
│ ├─── Instance 1 (Scalping) │
|
||||
│ ├─── Instance 2 (Intraday) │
|
||||
│ └─── Instance 3 (Swing) │
|
||||
│ │
|
||||
│ Shared: │
|
||||
│ ├─ Redis (Cache) │
|
||||
│ ├─ PostgreSQL (Positions) │
|
||||
│ └─ Message Queue (RabbitMQ) │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
#### Vertical Scaling
|
||||
|
||||
- Augmenter RAM pour cache plus large
|
||||
- Plus de CPU cores pour ML parallèle
|
||||
- SSD NVMe pour I/O rapide
|
||||
|
||||
---
|
||||
|
||||
**Architecture complète et évolutive !**
|
||||
Reference in New Issue
Block a user