Update app.py

app.py

@@ -257,6 +257,19 @@ def create_features(data: pd.DataFrame) -> pd.DataFrame:
             np.sign(df['LagRet_3'])
         ) / 3.0
 
+    # ── Horizon-aware features (2-day dynamics) ───────────────────────────────
+    # These explicitly capture 2-day structure to boost multi-day accuracy.
+    df['LagRet_1_2sum']  = df['LagRet_1'] + df['LagRet_2']           # 2-day return sum
+    df['LagRet_1_2diff'] = df['LagRet_1'] - df['LagRet_2']           # acceleration
+    df['Vol_2']          = df['Returns'].rolling(2).std()             # 2-day volatility
+    df['ROC_2']          = df['Close'].pct_change(2)                  # 2-day ROC
+    df['SMA3_slope']     = df['SMA_3'].diff(2)                        # short MA 2-day slope
+    df['EMA3_slope']     = df['EMA_3'].diff(2)                        # short EMA 2-day slope
+    df['ATR_delta']      = df['ATR'].diff(1)                          # ATR change (vol expansion/contraction)
+    df['RSI14_delta']    = df['RSI_14'].diff(2)                       # RSI momentum 2-day
+    df['MACD_Hist_delta']= df['MACD_Hist'].diff(2)                    # MACD histogram acceleration
+    df['BB_pct20_delta'] = df['BB_pct_20'].diff(2)                    # BB position change
+
     return df.dropna()
 
 
@@ -299,6 +312,10 @@ FEATURE_COLS = [
     'Volume_Ratio', 'OBV_Signal',
     # Direction composite (FIX 4)
     'Direction_Score', 'Momentum_Consistency',
+    # Horizon-aware (2-day dynamics)
+    'LagRet_1_2sum', 'LagRet_1_2diff', 'Vol_2', 'ROC_2',
+    'SMA3_slope', 'EMA3_slope', 'ATR_delta',
+    'RSI14_delta', 'MACD_Hist_delta', 'BB_pct20_delta',
 ]
 
 
@@ -322,13 +339,20 @@ def build_ridge_pipeline(alpha: float) -> Pipeline:
 def select_best_alpha(X_tr, y_tr) -> float:
     """
     RidgeCV finds optimal alpha from a fine logarithmic grid.
-    Evaluated on 5-fold time-series split (no shuffle).
+    FIXED: alpha is selected on poly-expanded features (same space as the
+    actual Ridge model), not on raw features. This eliminates alpha
+    scale mismatch that degraded 2-day accuracy.
     """
-    alphas = np.logspace(-3, 4, 60)
-    scaler = StandardScaler()
-    Xs = scaler.fit_transform(X_tr)
+    sc1  = StandardScaler()
+    poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
+    sc2  = StandardScaler(with_mean=False)
+    Xp   = sc2.fit_transform(poly.fit_transform(sc1.fit_transform(X_tr)))
+
+    # After poly expansion the feature count is ~n*(n-1)/2 — ridge needs
+    # higher alphas to stay regularised at that scale.
+    alphas = np.logspace(0, 6, 60)
     rcv = RidgeCV(alphas=alphas, cv=5, scoring='neg_mean_absolute_error')
-    rcv.fit(Xs, y_tr)
+    rcv.fit(Xp, y_tr)
     return float(rcv.alpha_)
 
 
@@ -336,15 +360,17 @@ def train_ridge(df: pd.DataFrame, horizon: int = 1):
     """
     Trains the premium Ridge model.
     Target: log-return over `horizon` days (direction-aware).
-    Returns pipeline, test predictions (absolute), y_test (absolute), avail_cols.
+
+    FIXES applied:
+    - Log-return target correctly encodes h-day return (not 1-day)
+    - Residual bias correction: calibrates systematic over/under-shoot
+    - Returns pipeline, test predictions (absolute), y_test (absolute), avail_cols.
     """
     avail = [c for c in FEATURE_COLS if c in df.columns]
     X     = df[avail].values
     close = df['Close'].values
 
-    # --- FIX 1: Use log-return as target (direction-aware, scale-invariant) ---
-    # log-return = log(close[t+horizon] / close[t])
-    # This directly encodes direction: positive = UP, negative = DOWN
+    # h-day log-return — model learns this directly, no horizon scaling needed
     y_logret = np.log(close[horizon:] / close[:len(close) - horizon])
 
     X = X[:len(y_logret)]
@@ -355,7 +381,7 @@ def train_ridge(df: pd.DataFrame, horizon: int = 1):
     y_train, y_logret_test = y_logret[:split],   y_logret[split:]
     close_test            = close_aligned[split:]
 
-    # Find best alpha on training data only
+    # Find best alpha on poly-expanded training data
     best_alpha = select_best_alpha(X_train, y_train)
 
     # Build & fit pipeline
@@ -364,87 +390,33 @@ def train_ridge(df: pd.DataFrame, horizon: int = 1):
 
     # Test predictions → convert log-return back to absolute price
     logret_hat = pipe.predict(X_test)
-    pred_abs   = close_test * np.exp(logret_hat)
+
+    # Residual bias correction: remove mean systematic bias from log-return predictions
+    # This improves directional accuracy without leaking future info (computed on train residuals)
+    train_preds   = pipe.predict(X_train)
+    residual_bias = float(np.mean(y_train - train_preds))   # mean error on train set
+    logret_hat_corrected = logret_hat + residual_bias
+
+    pred_abs   = close_test * np.exp(logret_hat_corrected)
     y_test_abs = close_test * np.exp(y_logret_test)
 
     mae  = mean_absolute_error(y_test_abs, pred_abs)
 
-    return pipe, pred_abs, y_test_abs, avail, best_alpha, mae
+    return pipe, pred_abs, y_test_abs, avail, best_alpha, mae, residual_bias
 
 
 def predict_next_ridge(pipe, df: pd.DataFrame, avail: list,
-                       horizon: int = 1) -> float:
-    """Predict absolute close price horizon days ahead using log-return."""
-    cp = float(df['Close'].iloc[-1])
-    x  = df[avail].iloc[-1].values.reshape(1, -1)
-    logret = float(pipe.predict(x)[0])
-    # Scale logret by horizon for multi-day forecasts
-    return cp * np.exp(logret * horizon)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  FIBONACCI LEVELS  (son swing üzerinden)
-# ══════════════════════════════════════════════════════════════════════════════
-
-FIB_RATIOS = [0.0, 0.236, 0.382, 0.500, 0.618, 0.786, 1.0]
-FIB_COLORS = ['#FFB800', '#FF6B35', '#7B61FF', '#00D4FF', '#00FFB2', '#E8EDF5', '#FFB800']
-
-def compute_fibonacci_levels(df: pd.DataFrame, lookback: int = 55) -> dict:
-    """Son `lookback` barda swing high/low bulur, Fibonacci retracement seviyeleri döner."""
-    recent = df.tail(lookback)
-    swing_high = float(recent['High'].max())
-    swing_low  = float(recent['Low'].min())
-    diff = swing_high - swing_low
-    levels = {f"Fib {int(r*100)}%": swing_high - diff * r for r in FIB_RATIOS}
-    levels['_high'] = swing_high
-    levels['_low']  = swing_low
-    return levels
-
-
-def fibonacci_direction_signal(cp: float, fib: dict) -> dict:
-    """
-    Fiyatın hangi Fibonacci bölgesinde olduğunu tespit eder.
-    Destek/direnç yakınlığına göre yön skoru (+bias) üretir.
+                       horizon: int = 1, residual_bias: float = 0.0) -> float:
     """
-    high, low = fib['_high'], fib['_low']
-    diff = high - low
-    if diff < 1e-10:
-        return {'fib_score': 0, 'fib_zone': 'N/A', 'fib_bias': 'NÖTR', 'fib_nearest': 0.0}
-
-    # Normalize: fiyatın retracement içindeki yüzdesi (0=low, 1=high)
-    pos = (cp - low) / diff   # 0→1 arası
-
-    # Hangi seviyeye en yakın?
-    nearest_r = min(FIB_RATIOS, key=lambda r: abs(pos - (1 - r)))
-    nearest_price = high - diff * nearest_r
-    dist_pct = abs(cp - nearest_price) / diff * 100
-
-    # Yön bias:
-    # Fiyat 0.618 altında → destek bölgesi → LONG bias
-    # Fiyat 0.382 üstünde → direnç bölgesi → SHORT bias
-    # %50 bölgesi nötr
-    if pos < 0.382:          # Fiyat altta, güçlü destek
-        fib_score = +25
-        fib_bias  = "LONG ▲ (Destek)"
-    elif pos < 0.50:         # Alt-orta bölge
-        fib_score = +12
-        fib_bias  = "LONG ▲ (Zayıf Destek)"
-    elif pos > 0.618:        # Fiyat üstte, güçlü direnç
-        fib_score = -25
-        fib_bias  = "SHORT ▼ (Direnç)"
-    elif pos > 0.50:         # Üst-orta bölge
-        fib_score = -12
-        fib_bias  = "SHORT ▼ (Zayıf Direnç)"
-    else:
-        fib_score = 0
-        fib_bias  = "NÖTR (%50)"
+    Predict absolute close price horizon days ahead using log-return.
 
-    return {
-        'fib_score':   fib_score,
-        'fib_zone':    f"{pos*100:.1f}% (Fib {int(nearest_r*100)}%'e yakın, Δ{dist_pct:.1f}%)",
-        'fib_bias':    fib_bias,
-        'fib_nearest': nearest_price,
-    }
+    FIXED: Removed `* horizon` scaling — model already learns h-day log-return.
+    Applies residual_bias correction from training set for calibrated prediction.
+    """
+    cp = float(df['Close'].iloc[-1])
+    x  = df[avail].iloc[-1].values.reshape(1, -1)
+    logret = float(pipe.predict(x)[0]) + residual_bias
+    return cp * np.exp(logret)
 
 
 # ══════════════════════════════════════════════════════════════════════════════
@@ -510,20 +482,6 @@ def signal_score(df: pd.DataFrame, direction: str) -> dict:
     return {'score': min(100, score), 'label': label, 'details': det}
 
 
-def signal_score_with_fib(df: pd.DataFrame, direction: str, fib_signal: dict) -> dict:
-    """signal_score + Fibonacci yön skoru."""
-    base    = signal_score(df, direction)
-    fs      = fib_signal['fib_score']
-    aligned = (direction == "LONG" and fs > 0) or (direction == "SHORT" and fs < 0)
-    contrib = abs(fs) if aligned else -(abs(fs) // 2)
-    new_score = int(np.clip(base['score'] + contrib, 0, 100))
-    label = "GÜÇLÜ ✅" if new_score >= 75 else ("ORTA ⚠️" if new_score >= 45 else "ZAYIF ❌")
-    base['details']['Fibonacci'] = f"{fib_signal['fib_bias']}  →  {'+' if contrib >= 0 else ''}{contrib}p"
-    base['score'] = new_score
-    base['label'] = label
-    return base
-
-
 # ══════════════════════════════════════════════════════════════════════════════
 #  CHART ENGINE  — phosphor-green terminal aesthetic
 # ══════════════════════════════════════════════════════════════════════════════
@@ -543,8 +501,7 @@ def _ax_style(ax, title="", ylabel=""):
 
 
 def build_figure(df, pred_price, horizon, tp_sl,
-                 test_pred_abs, y_test_abs, best_alpha, mae,
-                 fib_levels: dict = None) -> plt.Figure:
+                 test_pred_abs, y_test_abs, best_alpha, mae) -> plt.Figure:
 
     plt.rcParams.update({
         'font.family':       'monospace',
@@ -605,18 +562,6 @@ def build_figure(df, pred_price, horizon, tp_sl,
     ax_price.axhline(tp_sl['sl'], color=RED,   lw=1.4, ls='--', alpha=0.9, zorder=6)
     ax_price.axhline(cp,          color=TEXT,  lw=0.7, ls='-',  alpha=0.35, zorder=4)
 
-    # ── FIBONACCI levels ──────────────────────────────────────────────────────
-    if fib_levels:
-        fib_draw = [(r, c) for r, c in zip(FIB_RATIOS, FIB_COLORS)]
-        for ratio, col in fib_draw:
-            key = f"Fib {int(ratio*100)}%"
-            if key in fib_levels:
-                fval = fib_levels[key]
-                ax_price.axhline(fval, color=col, lw=0.7, ls=':', alpha=0.55, zorder=3)
-                ax_price.text(0.5, fval, f"  {key} {fval:.5f}",
-                              color=col, fontsize=6.5, va='bottom', alpha=0.75,
-                              fontfamily='monospace', transform=ax_price.get_yaxis_transform())
-
     r = len(idx) * 0.018
     for val, lbl, col in [
         (tp_sl['tp'], f"TP {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f}p)", GREEN),
@@ -753,10 +698,10 @@ def predict_eurusd(horizon: int = 1):
             return "❌ Yetersiz veri (min 40 satır gerekli).", None
 
         # 3. Train Ridge + backtest
-        pipe, test_pred_abs, y_test_abs, avail, best_alpha, mae = train_ridge(df, horizon)
+        pipe, test_pred_abs, y_test_abs, avail, best_alpha, mae, residual_bias = train_ridge(df, horizon)
 
         # 4. Predict next
-        pred_price = predict_next_ridge(pipe, df, avail, horizon)
+        pred_price = predict_next_ridge(pipe, df, avail, horizon, residual_bias)
 
         # 5. TP/SL
         cp  = float(df['Close'].iloc[-1])
@@ -764,12 +709,8 @@ def predict_eurusd(horizon: int = 1):
         tp_sl = compute_tp_sl(cp, pred_price, atr,
                                atr_multiplier_sl=1.5, rr_ratio=2.0)
 
-        # 5b. Fibonacci seviyeleri & yön sinyali
-        fib        = compute_fibonacci_levels(df, lookback=55)
-        fib_signal = fibonacci_direction_signal(cp, fib)
-
-        # 6. Signal score (fibonacci dahil)
-        sig = signal_score_with_fib(df, tp_sl['direction'], fib_signal)
+        # 6. Signal score
+        sig = signal_score(df, tp_sl['direction'])
 
         # 7. Backtest metrics
         rmse = float(np.sqrt(np.mean((test_pred_abs - y_test_abs) ** 2)))
@@ -816,6 +757,7 @@ def predict_eurusd(horizon: int = 1):
             f"  {f'+{horizon}G TAHMİN (RIDGE)':<24}:  {pred_price:.5f}  ({chg:+.3f}%)",
             f"  {'YÖN':<24}:  {tp_sl['direction']}",
             f"  {'OPTİMAL ALPHA (RidgeCV)':<24}:  {best_alpha:.6f}",
+        f"  {'BIAS DÜZELTME (log-ret)':<24}:  {residual_bias:+.7f}",
             "",
             f"  {'─── RİSK YÖNETİMİ (ATR × 1.5  |  R:R 1:2)':<{W-2}}",
             f"  {'GİRİŞ':<24}:  {tp_sl['entry']:.5f}",
@@ -825,17 +767,7 @@ def predict_eurusd(horizon: int = 1):
             f"  {'RİSK %':<24}:  {tp_sl['risk_pct']:.3f}%",
             f"  {'ATR-14':<24}:  {atr:.5f}",
             "",
-            f"  {'─── FİBONACCİ SEVİYELERİ (55 Bar)':<{W-2}}",
-            f"  {'Swing High':<24}:  {fib['_high']:.5f}",
-            f"  {'Swing Low':<24}:  {fib['_low']:.5f}",
-            f"  {'Fiyat Pozisyonu':<24}:  {fib_signal['fib_zone']}",
-            f"  {'Fibonacci Bias':<24}:  {fib_signal['fib_bias']}",
-        ] + [
-            f"  {'  Fib ' + k.split()[1]:<24}:  {v:.5f}"
-            for k, v in fib.items() if k.startswith('Fib')
-        ] + [
-            "",
-            f"  {'─── SİNYAL GÜCÜ (Fibonacci Dahil)':<{W-2}}",
+            f"  {'─── SİNYAL GÜCÜ':<{W-2}}",
             f"  {'SKOR':<24}:  {sig['score']:.0f} / 100  →  {sig['label']}",
         ]
         for k, v in sig['details'].items():
@@ -872,7 +804,6 @@ def predict_eurusd(horizon: int = 1):
         fig = build_figure(
             df, pred_price, horizon, tp_sl,
             test_pred_abs, y_test_abs, best_alpha, mae,
-            fib_levels=fib,
         )
 
         return text, fig