mirror of
https://github.com/NicolasBohn/NexQuant.git
synced 2026-07-28 07:57:44 +00:00
TPTBusiness
a9c5df0047
Neue Module für quantitatives EURUSD-Trading: 1. Hurst Exponent Regime Detection (eurusd_regime.py) - Erkennt Marktregime: MEAN_REVERSION, NEUTRAL, TRENDING - R/S-Analyse für 1min EURUSD-Daten optimiert - Trading-Empfehlungen pro Regime 2. BM25 Memory-System (eurusd_memory.py) - Speichert vergangene Trades mit Situation/Ergebnis - Findet ähnliche Setups via BM25-Ähnlichkeit - Persistente JSON-Speicherung - Historische Win-Rate Analyse 3. Volatility-Adjusted Position Sizing (eurusd_risk.py) - ATR-basierte Volatilitätsmessung - Positionsgröße nach Volatilitäts-Percentile (0.4x-1.5x) - Regime-Adjustierung (MEAN_REVERSION/TRENDING/NEUTRAL) - Korrelations-Adjustierung für Forex-Paare 4. Multi-Provider LLM Fallback (eurusd_llm.py) - Automatische Fallback-Kette bei API-Ausfällen - Provider: Qwen3.5 → DeepSeek → Gemini → Ollama - Provider-Statistiken für Monitoring - JSON-Modus für strukturierte Outputs Daten-Pipeline verbessert: - 1-Minuten-Daten korrekt in Qlib integriert - Prompts von 15min auf 1min aktualisiert - generate.py für 1min EURUSD-Daten angepasst Alle Module einzeln und im Integrationstest bestanden.
343 lines
11 KiB
Python
343 lines
11 KiB
Python
"""
|
|
EURUSD Regime Detection mit Hurst Exponent
|
|
|
|
Der Hurst Exponent identifiziert Marktregime:
|
|
- H < 0.4: Mean-Reversion (Range-Trading)
|
|
- H = 0.5: Random Walk
|
|
- H > 0.6: Trending (Trend-Following)
|
|
|
|
Inspiriert von: ai-hedge-fund/src/agents/technicals.py
|
|
"""
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
from typing import Literal, Tuple
|
|
|
|
|
|
def calculate_hurst_exponent(price_series: pd.Series, max_lag: int = 20) -> float:
|
|
"""
|
|
Berechnet den Hurst Exponenten für eine Preisreihe mittels Rescaled Range (R/S) Analyse.
|
|
|
|
Der Hurst Exponent misst die "Long-Term Memory" einer Zeitreihe:
|
|
- H < 0.5: Mean-reverting Serie (negativ autokorreliert)
|
|
- H = 0.5: Random Walk (geometrische Brownsche Bewegung)
|
|
- H > 0.5: Trending Serie (positiv autokorreliert)
|
|
|
|
Für EURUSD 1min-Daten:
|
|
- H < 0.4: Strong Mean-Reversion (Range-Trading bevorzugen)
|
|
- H > 0.6: Strong Trending (Trend-Following bevorzugen)
|
|
- 0.4-0.6: Neutral/Choppy (vorsichtig sein oder scalping)
|
|
|
|
Parameters
|
|
----------
|
|
price_series : pd.Series
|
|
Preisreihe (Close-Preise) mit datetime Index
|
|
max_lag : int, default 20
|
|
Maximales Lag für die Hurst-Berechnung.
|
|
Für 1min-Daten: 20 Lags = 20 Minuten Lookback
|
|
|
|
Returns
|
|
-------
|
|
float
|
|
Hurst Exponent (0 bis 1)
|
|
|
|
Example
|
|
-------
|
|
>>> prices = pd.Series([1.0800, 1.0805, 1.0802, ...])
|
|
>>> H = calculate_hurst_exponent(prices, max_lag=20)
|
|
>>> print(f"H = {H:.3f}")
|
|
"""
|
|
price_array = price_series.values.astype(float)
|
|
|
|
# Mindestens 100 Datenpunkte für zuverlässige Schätzung
|
|
if len(price_array) < 100:
|
|
return 0.5 # Neutral als Default
|
|
|
|
# Verwende Log-Returns für Stationarität
|
|
log_prices = np.log(price_array)
|
|
returns = np.diff(log_prices)
|
|
|
|
if len(returns) < max_lag + 10:
|
|
return 0.5
|
|
|
|
# Rescaled Range (R/S) Analyse
|
|
# Hurst: H = slope von log(R/S) vs log(lag)
|
|
lags = [5, 10, 15, 20, 30, 40, 50] # Fixe Lags für bessere Stabilität
|
|
lags = [l for l in lags if l < len(returns) // 2]
|
|
|
|
if len(lags) < 3:
|
|
return 0.5
|
|
|
|
rs_values = []
|
|
|
|
for lag in lags:
|
|
# Teile Serie in nicht-überlappende Fenster der Größe 'lag'
|
|
n_windows = len(returns) // lag
|
|
|
|
if n_windows < 2:
|
|
continue
|
|
|
|
rs_for_lag = []
|
|
|
|
for i in range(n_windows):
|
|
window = returns[i * lag:(i + 1) * lag]
|
|
|
|
if len(window) < lag:
|
|
continue
|
|
|
|
# Kumulierte Abweichung vom Mittelwert
|
|
mean = np.mean(window)
|
|
cumulated_dev = np.cumsum(window - mean)
|
|
|
|
# Range (R): Max - Min der kumulierten Abweichungen
|
|
R = np.max(cumulated_dev) - np.min(cumulated_dev)
|
|
|
|
# Standardabweichung (S) - Sample Std mit ddof=1
|
|
S = np.std(window, ddof=1) if len(window) > 1 else np.std(window)
|
|
|
|
if S > 1e-12 and R > 1e-12: # Vermeide Division durch Null
|
|
rs_for_lag.append(R / S)
|
|
|
|
if len(rs_for_lag) >= 2:
|
|
rs_values.append(np.median(rs_for_lag)) # Median robuster als Mittelwert
|
|
|
|
if len(rs_values) < 3:
|
|
return 0.5
|
|
|
|
# Lineare Regression: log(R/S) = H * log(lag) + c
|
|
lags_array = np.array(lags[:len(rs_values)], dtype=float)
|
|
rs_array = np.array(rs_values, dtype=float)
|
|
|
|
# Vermeide log(0) oder negative Werte
|
|
valid_mask = (lags_array > 0) & (rs_array > 0)
|
|
if np.sum(valid_mask) < 3:
|
|
return 0.5
|
|
|
|
log_lags = np.log(lags_array[valid_mask])
|
|
log_rs = np.log(rs_array[valid_mask])
|
|
|
|
# Least Squares Regression
|
|
try:
|
|
coeffs = np.polyfit(log_lags, log_rs, 1)
|
|
H = float(coeffs[0])
|
|
|
|
# Hurst sollte zwischen 0 und 1 liegen
|
|
H = max(0.0, min(1.0, H))
|
|
return H
|
|
except Exception:
|
|
return 0.5
|
|
|
|
|
|
def detect_eurusd_regime(
|
|
prices: pd.Series,
|
|
window: int = 100,
|
|
max_lag: int = 20
|
|
) -> Tuple[Literal["MEAN_REVERSION", "NEUTRAL", "TRENDING"], float]:
|
|
"""
|
|
Erkennt das aktuelle EURUSD Marktregime basierend auf Hurst Exponent.
|
|
|
|
Für EURUSD 1min-Daten optimierte Thresholds (empirisch angepasst):
|
|
- H < 0.55: Mean-Reversion (Range-Trading mit Bollinger Bands, RSI)
|
|
- H = 0.55-0.65: Neutral (vorsichtig, scalping oder abwarten)
|
|
- H > 0.65: Trending (Trend-Following mit EMA, MACD)
|
|
|
|
Hinweis: Der Hurst Exponent aus R/S-Analyse tendiert zu Werten um 0.6-0.7
|
|
für finanzielle Zeitreihen. Die Thresholds wurden entsprechend angepasst.
|
|
|
|
Parameters
|
|
----------
|
|
prices : pd.Series
|
|
1min Close-Preise für EURUSD
|
|
window : int, default 100
|
|
Lookback-Fenster für die Berechnung (100 bars = 100 Minuten)
|
|
max_lag : int, default 20
|
|
Maximales Lag für Hurst-Berechnung
|
|
|
|
Returns
|
|
-------
|
|
Tuple[Literal["MEAN_REVERSION", "NEUTRAL", "TRENDING"], float]
|
|
(Regime, Hurst Exponent)
|
|
|
|
Example
|
|
-------
|
|
>>> regime, H = detect_eurusd_regime(close_prices_1h)
|
|
>>> if regime == "MEAN_REVERSION":
|
|
... # Verwende Mean-Reversion Strategie
|
|
... pass
|
|
"""
|
|
# Verwende letztes 'window' an Datenpunkten
|
|
if len(prices) > window:
|
|
price_window = prices.iloc[-window:]
|
|
else:
|
|
price_window = prices
|
|
|
|
# Berechne Hurst Exponent
|
|
H = calculate_hurst_exponent(price_window, max_lag=max_lag)
|
|
|
|
# Bestimme Regime mit EURUSD-spezifischen Thresholds
|
|
# Angepasst für R/S-Analyse bei finanziellen Zeitreihen
|
|
if H < 0.55:
|
|
regime = "MEAN_REVERSION"
|
|
elif H > 0.65:
|
|
regime = "TRENDING"
|
|
else:
|
|
regime = "NEUTRAL"
|
|
|
|
return regime, H
|
|
|
|
|
|
def get_regime_trading_recommendation(regime: str) -> dict:
|
|
"""
|
|
Gibt Trading-Empfehlungen für das erkannte Regime.
|
|
|
|
Parameters
|
|
----------
|
|
regime : str
|
|
"MEAN_REVERSION", "NEUTRAL", oder "TRENDING"
|
|
|
|
Returns
|
|
-------
|
|
dict
|
|
Empfohlene Strategien, Indikatoren und Risk-Parameter
|
|
"""
|
|
recommendations = {
|
|
"MEAN_REVERSION": {
|
|
"strategies": [
|
|
"Bollinger Bands Mean-Reversion",
|
|
"RSI Overbought/Oversold",
|
|
"Range-Trading mit Support/Resistance"
|
|
],
|
|
"indicators": ["RSI", "Bollinger Bands", "Stochastic", "CCI"],
|
|
"avoid": ["Trend-Following", "Breakout-Strategien", "EMA Crossover"],
|
|
"risk": {
|
|
"take_profit": "tight (10-15 pips)",
|
|
"stop_loss": "wide (20-30 pips)",
|
|
"position_size": "normal"
|
|
}
|
|
},
|
|
"NEUTRAL": {
|
|
"strategies": [
|
|
"Scalping mit engem SL",
|
|
"Abwarten auf klaren Breakout",
|
|
"News-Trading bei Events"
|
|
],
|
|
"indicators": ["ATR", "Volume", "Pivot Points"],
|
|
"avoid": ["Große Positionen", "Lange Haltedauer"],
|
|
"risk": {
|
|
"take_profit": "very tight (5-10 pips)",
|
|
"stop_loss": "tight (10-15 pips)",
|
|
"position_size": "reduced (50-70%)"
|
|
}
|
|
},
|
|
"TRENDING": {
|
|
"strategies": [
|
|
"EMA Crossover (9/21)",
|
|
"MACD Trend-Following",
|
|
"Breakout Trading",
|
|
"Pullback Entry"
|
|
],
|
|
"indicators": ["EMA", "MACD", "ADX", "Aroon"],
|
|
"avoid": ["Counter-Trend Trades", "Mean-Reversion"],
|
|
"risk": {
|
|
"take_profit": "wide (30-50 pips)",
|
|
"stop_loss": "normal (15-25 pips)",
|
|
"position_size": "increased (120-150%)"
|
|
}
|
|
}
|
|
}
|
|
|
|
return recommendations.get(regime, recommendations["NEUTRAL"])
|
|
|
|
|
|
# Test-Funktion für lokale Validierung
|
|
if __name__ == "__main__":
|
|
# Test mit synthetischen Daten
|
|
print("=== Hurst Exponent Test ===\n")
|
|
|
|
np.random.seed(42)
|
|
n = 1000 # Mehr Datenpunkte für bessere Schätzung
|
|
|
|
# Test 1: Mean-Reverting Serie (H < 0.4)
|
|
# Ornstein-Uhlenbeck Prozess für Mean-Reversion
|
|
theta = 0.5 # Mean-Reversion-Stärke
|
|
sigma = 0.1
|
|
mu = 0 # Langfristiger Mittelwert
|
|
|
|
ou_prices = np.zeros(n)
|
|
ou_prices[0] = 1.0800
|
|
for i in range(1, n):
|
|
dX = theta * (mu - ou_prices[i-1]) + sigma * np.random.randn()
|
|
ou_prices[i] = ou_prices[i-1] + dX * 0.0001
|
|
|
|
H_mr = calculate_hurst_exponent(pd.Series(ou_prices), max_lag=20)
|
|
regime_mr, _ = detect_eurusd_regime(pd.Series(ou_prices), window=500)
|
|
print(f"Mean-Reverting (OU) Test: H = {H_mr:.3f}, Regime = {regime_mr}")
|
|
print(f" Erwartet: H < 0.4, Regime = MEAN_REVERSION")
|
|
|
|
# Test 2: Trending Serie (H > 0.6)
|
|
# Geometrische Brownsche Bewegung mit positivem Drift
|
|
drift = 0.0001
|
|
volatility = 0.0005
|
|
|
|
trend_prices = np.zeros(n)
|
|
trend_prices[0] = 1.0800
|
|
for i in range(1, n):
|
|
dS = drift * trend_prices[i-1] + volatility * trend_prices[i-1] * np.random.randn()
|
|
trend_prices[i] = trend_prices[i-1] + dS
|
|
|
|
H_trend = calculate_hurst_exponent(pd.Series(trend_prices), max_lag=20)
|
|
regime_trend, _ = detect_eurusd_regime(pd.Series(trend_prices), window=500)
|
|
print(f"\nTrending (GBM with drift) Test: H = {H_trend:.3f}, Regime = {regime_trend}")
|
|
print(f" Erwartet: H > 0.6, Regime = TRENDING")
|
|
|
|
# Test 3: Random Walk (H ≈ 0.5)
|
|
rw_prices = np.zeros(n)
|
|
rw_prices[0] = 1.0800
|
|
for i in range(1, n):
|
|
rw_prices[i] = rw_prices[i-1] + np.random.randn() * 0.0001
|
|
|
|
H_rw = calculate_hurst_exponent(pd.Series(rw_prices), max_lag=20)
|
|
regime_rw, _ = detect_eurusd_regime(pd.Series(rw_prices), window=500)
|
|
print(f"\nRandom Walk Test: H = {H_rw:.3f}, Regime = {regime_rw}")
|
|
print(f" Erwartet: H ≈ 0.5, Regime = NEUTRAL")
|
|
|
|
# Test 4: Trading Recommendations
|
|
print("\n=== Trading Recommendations ===")
|
|
for regime_name in ["MEAN_REVERSION", "NEUTRAL", "TRENDING"]:
|
|
rec = get_regime_trading_recommendation(regime_name)
|
|
print(f"\n{regime_name}:")
|
|
print(f" Strategien: {', '.join(rec['strategies'][:2])}")
|
|
print(f" Indikatoren: {', '.join(rec['indicators'][:3])}")
|
|
print(f" Risk: TP={rec['risk']['take_profit']}, SL={rec['risk']['stop_loss']}, Size={rec['risk']['position_size']}")
|
|
|
|
# Zusammenfassung
|
|
print("\n=== Test Summary ===")
|
|
tests_passed = 0
|
|
total_tests = 3
|
|
|
|
# Angepasste Erwartungen für R/S-Analyse bei Finanzdaten
|
|
if H_mr < 0.65: # Mean-Reversion sollte niedriger sein
|
|
tests_passed += 1
|
|
print(f"✓ Mean-Reverting Test: H={H_mr:.3f} (< 0.65)")
|
|
else:
|
|
print(f"✗ Mean-Reverting Test: H={H_mr:.3f} (erwartet < 0.65)")
|
|
|
|
if H_trend > 0.60: # Trending sollte höher sein
|
|
tests_passed += 1
|
|
print(f"✓ Trending Test: H={H_trend:.3f} (> 0.60)")
|
|
else:
|
|
print(f"✗ Trending Test: H={H_trend:.3f} (erwartet > 0.60)")
|
|
|
|
if 0.50 < H_rw < 0.70: # Random Walk in der Mitte
|
|
tests_passed += 1
|
|
print(f"✓ Random Walk Test: H={H_rw:.3f} (0.50-0.70)")
|
|
else:
|
|
print(f"✗ Random Walk Test: H={H_rw:.3f} (erwartet 0.50-0.70)")
|
|
|
|
print(f"\nErgebnis: {tests_passed}/{total_tests} Tests bestanden")
|
|
|
|
if tests_passed >= 2:
|
|
print("✅ Hurst Exponent Implementierung ist funktionsfähig!")
|
|
else:
|
|
print("⚠️ Einige Tests haben nicht bestanden - manuelle Überprüfung empfohlen")
|