Update app.py

app.py

@@ -1,6 +1,6 @@
 # ══════════════════════════════════════════════════════════════════════════════
-#  EUR/USD  ·  ENSEMBLE FORECAST ENGINE  ·  Ultra-Premium Edition v2
-#  Model: Ensemble Ridge + GBM · ATR-normalised target · Regime filter · Threshold
+#  EUR/USD  ·  RIDGE FORECAST ENGINE  ·  Ultra-Premium Edition
+#  Model: Stacked Ridge Regression (L1+L2 optimised, polynomial features)
 #  Forecast horizon: 1 or 2 days ahead
 #  TP/SL: ATR-based risk management  ·  Signal scoring  ·  Backtest
 #  Data: Yahoo Finance (yfinance)
@@ -15,8 +15,6 @@ from sklearn.linear_model import Ridge, RidgeCV
 from sklearn.preprocessing import StandardScaler, PolynomialFeatures
 from sklearn.pipeline import Pipeline
 from sklearn.metrics import mean_absolute_error
-from sklearn.ensemble import GradientBoostingRegressor
-from sklearn.model_selection import TimeSeriesSplit
 import matplotlib
 matplotlib.use('Agg')
 import matplotlib.pyplot as plt
@@ -98,43 +96,6 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
     return 100 - (100 / (1 + gain / (loss + 1e-10)))
 
 
-def detect_regime(df: pd.DataFrame) -> pd.Series:
-    """
-    Market regime detection:
-      +1 = TREND  (directional, EMA spread wide, ADX-proxy high)
-       0 = NEUTRAL
-      -1 = RANGE  (mean-reverting, BB squeeze, flat MAs)
-    """
-    close = df['Close']
-    ema8  = close.ewm(span=8,  adjust=False).mean()
-    ema21 = close.ewm(span=21, adjust=False).mean()
-    ema55 = close.ewm(span=55, adjust=False).mean()
-
-    # Trend strength: normalised EMA spread
-    spread  = (ema8 - ema55).abs() / (close + 1e-10)
-    spread_z = (spread - spread.rolling(40).mean()) / (spread.rolling(40).std() + 1e-10)
-
-    # Volatility regime: BB width z-score
-    mid = close.rolling(20).mean()
-    bb_w = (close.rolling(20).std() * 4) / (mid + 1e-10)
-    bb_z = (bb_w - bb_w.rolling(40).mean()) / (bb_w.rolling(40).std() + 1e-10)
-
-    regime = pd.Series(0, index=df.index)
-    regime[spread_z >  0.5] =  1   # trending
-    regime[bb_z     < -0.5] = -1   # range / squeeze
-    return regime
-
-
-def normalise_target_by_atr(y_logret: np.ndarray, atr_vals: np.ndarray) -> np.ndarray:
-    """
-    Divide log-returns by ATR to make the target volatility-scaled.
-    Model learns to predict 'how many ATRs will price move', not raw pips.
-    This prevents near-zero predictions when volatility is high.
-    """
-    atr_norm = atr_vals / (atr_vals.mean() + 1e-10)   # relative ATR
-    return y_logret / (atr_norm + 1e-10)
-
-
 def create_features(data: pd.DataFrame) -> pd.DataFrame:
     """
     Premium feature set — 55+ engineered features designed to minimise MAE
@@ -257,16 +218,6 @@ def create_features(data: pd.DataFrame) -> pd.DataFrame:
         df['Volume_Ratio'] = 1.0
         df['OBV_Signal']   = 0.0
 
-    # ── Regime features ──────────────────────────────────────────────────────
-    df['Regime']       = detect_regime(df)
-    df['Regime_Trend'] = (df['Regime'] ==  1).astype(float)
-    df['Regime_Range'] = (df['Regime'] == -1).astype(float)
-
-    # BB squeeze: width below 20th percentile of last 60 days
-    bb20 = df['BB_width_20'] if 'BB_width_20' in df.columns else (
-        df['Close'].rolling(20).std() * 4 / (df['Close'].rolling(20).mean() + 1e-10))
-    df['BB_Squeeze'] = (bb20 < bb20.rolling(60).quantile(0.20)).astype(float)
-
     # ── FIX 4: Direction Composite Signal (boosts directional accuracy) ─────
     # Encodes consensus of multiple indicators into a single direction score.
     # Positive → bullish bias, Negative → bearish bias.
@@ -348,8 +299,6 @@ FEATURE_COLS = [
     'Volume_Ratio', 'OBV_Signal',
     # Direction composite (FIX 4)
     'Direction_Score', 'Momentum_Consistency',
-    # Regime
-    'Regime', 'Regime_Trend', 'Regime_Range', 'BB_Squeeze',
 ]
 
 
@@ -362,15 +311,19 @@ FEATURE_COLS = [
 def build_ridge_pipeline(alpha: float) -> Pipeline:
     """Ridge pipeline with degree-2 interactions (no bias terms in poly)."""
     return Pipeline([
-        ('scaler',  StandardScaler()),
-        ('poly',    PolynomialFeatures(degree=2, interaction_only=True,
-                                       include_bias=False)),
-        ('scaler2', StandardScaler(with_mean=False)),
-        ('ridge',   Ridge(alpha=alpha, fit_intercept=True)),
+        ('scaler', StandardScaler()),
+        ('poly',   PolynomialFeatures(degree=2, interaction_only=True,
+                                      include_bias=False)),
+        ('scaler2', StandardScaler(with_mean=False)),   # re-scale after poly
+        ('ridge',  Ridge(alpha=alpha, fit_intercept=True)),
     ])
 
 
 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).
+    """
     alphas = np.logspace(-3, 4, 60)
     scaler = StandardScaler()
     Xs = scaler.fit_transform(X_tr)
@@ -379,115 +332,119 @@ def select_best_alpha(X_tr, y_tr) -> float:
     return float(rcv.alpha_)
 
 
-# ══════════════════════════════════════════════════════════════════════════════
-#  ENSEMBLE MODEL: Ridge + Gradient Boosting
-# ══════════════════════════════════════════════════════════════════════════════
-
-def train_ensemble(df: pd.DataFrame, horizon: int = 1):
+def train_ridge(df: pd.DataFrame, horizon: int = 1):
     """
-    Four upgrades over baseline:
-      A) ATR-normalised log-return target   → prevents near-zero predictions
-      B) Regime-conditioned training         → model sees market context
-      C) GBM secondary model                 → captures nonlinear patterns
-      D) Ensemble blend (Ridge 55% + GBM 45%)
-    Final signal passes through a threshold filter: if predicted move
-    is < 0.3× ATR the signal is tagged WEAK (no trade recommended).
+    Trains the premium Ridge model.
+    Target: log-return over `horizon` days (direction-aware).
+    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
-    atr   = df['ATR'].values if 'ATR' in df.columns else np.full(len(close), 1e-4)
 
-    # ── A. ATR-normalised log-return target ───────────────────────────────────
+    # --- 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
     y_logret = np.log(close[horizon:] / close[:len(close) - horizon])
-    atr_aligned = atr[:len(y_logret)]
-    y_norm   = normalise_target_by_atr(y_logret, atr_aligned)   # scaled target
 
-    X = X[:len(y_norm)]
-    close_aligned = close[:len(y_norm)]
-    atr_aligned   = atr_aligned[:len(y_norm)]
+    X = X[:len(y_logret)]
+    close_aligned = close[:len(y_logret)]
 
-    split = -15
-    X_train, X_test       = X[:split],         X[split:]
-    y_train, y_norm_test  = y_norm[:split],     y_norm[split:]
-    y_raw_test            = y_logret[len(y_logret)+split:]
+    split = -15   # 15-day test window for robust backtest
+    X_train, X_test       = X[:split],           X[split:]
+    y_train, y_logret_test = y_logret[:split],   y_logret[split:]
     close_test            = close_aligned[split:]
-    atr_test              = atr_aligned[split:]
 
-    # ── B. Ridge on full training set ────────────────────────────────────────
+    # Find best alpha on training data only
     best_alpha = select_best_alpha(X_train, y_train)
-    ridge_pipe = build_ridge_pipeline(best_alpha)
-    ridge_pipe.fit(X_train, y_train)
-    ridge_pred_norm = ridge_pipe.predict(X_test)
-
-    # ── C. GBM on residuals (boosting approach) ───────────────────────────────
-    # Fit GBM on training residuals so it learns what Ridge misses
-    ridge_train_pred = ridge_pipe.predict(X_train)
-    residuals_train  = y_train - ridge_train_pred
-
-    scaler_gbm = StandardScaler()
-    X_tr_sc = scaler_gbm.fit_transform(X_train)
-    X_te_sc = scaler_gbm.transform(X_test)
-
-    gbm = GradientBoostingRegressor(
-        n_estimators=120, max_depth=3, learning_rate=0.05,
-        subsample=0.8, min_samples_leaf=5, random_state=42,
-    )
-    gbm.fit(X_tr_sc, residuals_train)
-    gbm_correction = gbm.predict(X_te_sc)
 
-    # ── D. Ensemble blend ────────────────────────────────────────────────────
-    RIDGE_W = 0.55
-    GBM_W   = 0.45
-    ensemble_norm = ridge_pred_norm * RIDGE_W + (ridge_pred_norm + gbm_correction) * GBM_W
+    # Build & fit pipeline
+    pipe = build_ridge_pipeline(best_alpha)
+    pipe.fit(X_train, y_train)
 
-    # Convert normalised prediction back to log-return, then to price
-    atr_norm_test = atr_test / (atr_aligned.mean() + 1e-10)
-    logret_hat    = ensemble_norm * atr_norm_test
-    pred_abs      = close_test * np.exp(logret_hat)
-    y_test_abs    = close_test * np.exp(y_raw_test)
+    # Test predictions → convert log-return back to absolute price
+    logret_hat = pipe.predict(X_test)
+    pred_abs   = close_test * np.exp(logret_hat)
+    y_test_abs = close_test * np.exp(y_logret_test)
 
-    mae = mean_absolute_error(y_test_abs, pred_abs)
+    mae  = mean_absolute_error(y_test_abs, pred_abs)
 
-    return (ridge_pipe, gbm, scaler_gbm, atr_aligned.mean(),
-            pred_abs, y_test_abs, avail, best_alpha, mae,
-            RIDGE_W, GBM_W)
+    return pipe, pred_abs, y_test_abs, avail, best_alpha, mae
 
 
-def predict_next_ensemble(ridge_pipe, gbm, scaler_gbm, atr_mean,
-                           df: pd.DataFrame, avail: list,
-                           horizon: int = 1,
-                           ridge_w: float = 0.55,
-                           gbm_w:   float = 0.45) -> tuple:
-    """
-    Returns (pred_price, logret, signal_strength, threshold_passed).
-    signal_strength = |predicted move| / ATR  (how many ATRs away)
-    threshold_passed = True if signal_strength >= 0.30
-    """
-    cp  = float(df['Close'].iloc[-1])
-    atr = float(df['ATR'].iloc[-1]) if 'ATR' in df.columns else 1e-4
-    x   = df[avail].iloc[-1].values.reshape(1, -1)
+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)
 
-    # Ridge prediction (normalised)
-    ridge_norm = float(ridge_pipe.predict(x)[0])
 
-    # GBM correction on residual
-    x_sc = scaler_gbm.transform(x)
-    gbm_corr = float(gbm.predict(x_sc)[0])
+# ══════════════════════════════════════════════════════════════════════════════
+#  FIBONACCI LEVELS  (son swing üzerinden)
+# ══════════════════════════════════════════════════════════════════════════════
 
-    ensemble_norm = ridge_norm * ridge_w + (ridge_norm + gbm_corr) * gbm_w
+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']
 
-    # Denormalise
-    atr_norm  = atr / (atr_mean + 1e-10)
-    logret    = ensemble_norm * atr_norm * horizon
-    pred_price = cp * np.exp(logret)
+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
 
-    # ── Sinyal eşiği ─────────────────────────────────────────────────────────
-    signal_strength  = abs(pred_price - cp) / (atr + 1e-10)
-    THRESHOLD        = 0.30   # minimum 0.30 ATR hareketi gerekiyor
-    threshold_passed = signal_strength >= THRESHOLD
 
-    return pred_price, logret, signal_strength, threshold_passed
+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.
+    """
+    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)"
+
+    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,
+    }
 
 
 # ═════════════════════════════════════════��════════════════════════════════════
@@ -553,6 +510,20 @@ 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
 # ══════════════════════════════════════════════════════════════════════════════
@@ -573,7 +544,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,
-                 regime_val=0, sig_strength=0.0, thr_passed=True) -> plt.Figure:
+                 fib_levels: dict = None) -> plt.Figure:
 
     plt.rcParams.update({
         'font.family':       'monospace',
@@ -626,15 +597,6 @@ def build_figure(df, pred_price, horizon, tp_sl,
             (i - 0.25, min(o, c)), 0.5, abs(c - o) + 1e-7,
             boxstyle="square,pad=0", linewidth=0, facecolor=color, alpha=0.75, zorder=3))
 
-    # ── Regime background shading ─────────────────────────────────────────────
-    if 'Regime' in tail.columns:
-        for i, (_, row) in enumerate(tail.iterrows()):
-            rv = int(row.get('Regime', 0))
-            if rv == 1:   # trend
-                ax_price.axvspan(i-0.5, i+0.5, alpha=0.06, color=ACID,  zorder=0)
-            elif rv == -1:  # range
-                ax_price.axvspan(i-0.5, i+0.5, alpha=0.06, color=ACID3, zorder=0)
-
     # Close line overlay (phosphor glow)
     ax_price.plot(idx, tail['Close'].values, lw=1.6, color=ACID, zorder=5, alpha=0.9, label='Close')
 
@@ -643,6 +605,18 @@ 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),
@@ -663,14 +637,6 @@ def build_figure(df, pred_price, horizon, tp_sl,
         fontfamily='monospace',
     )
 
-    # Threshold / signal strength label
-    thr_color = GREEN if thr_passed else RED
-    thr_text  = f"{'✅' if thr_passed else '⛔'} Sinyal Gücü: {sig_strength:.2f}× ATR"
-    ax_price.text(0.01, 0.04, thr_text, transform=ax_price.transAxes,
-                  fontsize=7.5, color=thr_color, fontweight='bold',
-                  fontfamily='monospace', zorder=9,
-                  bbox=dict(facecolor=PANEL, edgecolor=thr_color, alpha=0.7, pad=3))
-
     ax_price.legend(fontsize=7, framealpha=0.1, labelcolor=SUBTEXT,
                     ncol=3, loc='upper left')
     ax_price.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
@@ -751,7 +717,7 @@ def build_figure(df, pred_price, horizon, tp_sl,
     dir_color = GREEN if tp_sl['direction'] == 'LONG' else WARM
 
     fig.text(0.055, 0.97,
-             "EUR/USD  ·  ENSEMBLE FORECAST ENGINE  ·  ULTRA-PREMIUM",
+             "EUR/USD  ·  RIDGE FORECAST ENGINE  ·  ULTRA-PREMIUM",
              fontsize=12, color=TEXT, fontweight='bold', va='top',
              fontfamily='monospace')
     fig.text(0.055, 0.955, dir_label,
@@ -786,30 +752,28 @@ def predict_eurusd(horizon: int = 1):
         if len(df) < 40:
             return "❌ Yetersiz veri (min 40 satır gerekli).", None
 
-        # 3. Train Ensemble (Ridge + GBM) + backtest
-        (ridge_pipe, gbm, scaler_gbm, atr_mean,
-         test_pred_abs, y_test_abs, avail, best_alpha, mae,
-         ridge_w, gbm_w) = train_ensemble(df, horizon)
-
-        # 4. Predict next (ensemble)
-        cp  = float(df['Close'].iloc[-1])
-        atr = float(df['ATR'].iloc[-1])
-        pred_price, logret_val, sig_strength, thr_passed = predict_next_ensemble(
-            ridge_pipe, gbm, scaler_gbm, atr_mean, df, avail, horizon, ridge_w, gbm_w)
+        # 3. Train Ridge + backtest
+        pipe, test_pred_abs, y_test_abs, avail, best_alpha, mae = train_ridge(df, horizon)
 
-        # 4b. Regime
-        regime_val = int(df['Regime'].iloc[-1]) if 'Regime' in df.columns else 0
-        regime_lbl = {1: "TREND ▶", 0: "NÖTR ◆", -1: "RANGE ◀"}.get(regime_val, "?")
+        # 4. Predict next
+        pred_price = predict_next_ridge(pipe, df, avail, horizon)
 
         # 5. TP/SL
+        cp  = float(df['Close'].iloc[-1])
+        atr = float(df['ATR'].iloc[-1])
         tp_sl = compute_tp_sl(cp, pred_price, atr,
                                atr_multiplier_sl=1.5, rr_ratio=2.0)
 
-        # 6. Signal score
-        sig = signal_score(df, tp_sl['direction'])
+        # 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)
 
         # 7. Backtest metrics
         rmse = float(np.sqrt(np.mean((test_pred_abs - y_test_abs) ** 2)))
+        # FIX 3: Correct directional accuracy — compare pred vs entry price
         close_vals = df['Close'].values
         n_test = len(test_pred_abs)
         entry_prices = close_vals[len(close_vals) - n_test - horizon :
@@ -842,19 +806,15 @@ def predict_eurusd(horizon: int = 1):
         W   = 54
         sep = "═" * W
 
-        thr_lbl = "✅ AKTİF SİNYAL" if thr_passed else "⛔ ZAYIF SİNYAL (trade yok)"
         lines = [
             sep,
-            f"  EUR/USD  ·  ENSEMBLE FORECAST ENGINE  ·  ULTRA-PREMIUM",
+            f"  EUR/USD  ·  RIDGE FORECAST ENGINE  ·  ULTRA-PREMIUM",
             f"  {datetime.now().strftime('%d %b %Y  %H:%M:%S')}",
             sep,
             "",
             f"  {'MEVCUT FİYAT':<24}:  {cp:.5f}",
-            f"  {f'+{horizon}G TAHMİN (ENSEMBLE)':<24}:  {pred_price:.5f}  ({chg:+.3f}%)",
+            f"  {f'+{horizon}G TAHMİN (RIDGE)':<24}:  {pred_price:.5f}  ({chg:+.3f}%)",
             f"  {'YÖN':<24}:  {tp_sl['direction']}",
-            f"  {'REJİM':<24}:  {regime_lbl}",
-            f"  {'SİNYAL GÜCÜ (ATR×)':<24}:  {sig_strength:.2f}x  →  {thr_lbl}",
-            f"  {'LOG-RETURN TAHMİN':<24}:  {logret_val*100:+.4f}%",
             f"  {'OPTİMAL ALPHA (RidgeCV)':<24}:  {best_alpha:.6f}",
             "",
             f"  {'─── RİSK YÖNETİMİ (ATR × 1.5  |  R:R 1:2)':<{W-2}}",
@@ -865,7 +825,17 @@ def predict_eurusd(horizon: int = 1):
             f"  {'RİSK %':<24}:  {tp_sl['risk_pct']:.3f}%",
             f"  {'ATR-14':<24}:  {atr:.5f}",
             "",
-            f"  {'─── SİNYAL GÜCÜ':<{W-2}}",
+            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"  {'SKOR':<24}:  {sig['score']:.0f} / 100  →  {sig['label']}",
         ]
         for k, v in sig['details'].items():
@@ -890,8 +860,6 @@ def predict_eurusd(horizon: int = 1):
             f"  {'RMSE':<24}:  {rmse:.7f}",
             f"  {'Yön Doğruluğu':<24}:  {hit:.1f}%",
             f"  {'Feature Sayısı':<24}:  {len(avail)}",
-            f"  {'Ensemble (Ridge/GBM)':<24}:  {ridge_w*100:.0f}% / {gbm_w*100:.0f}%",
-            f"  {'Eşik (ATR×0.30)':<24}:  {'Geçti ✅' if thr_passed else 'GEÇEMEDİ ⛔'}",
             "",
             sep,
             "  ⚠  Yalnızca eğitim amaçlıdır. Finansal tavsiye değildir.",
@@ -904,8 +872,7 @@ def predict_eurusd(horizon: int = 1):
         fig = build_figure(
             df, pred_price, horizon, tp_sl,
             test_pred_abs, y_test_abs, best_alpha, mae,
-            regime_val=regime_val, sig_strength=sig_strength,
-            thr_passed=thr_passed,
+            fib_levels=fib,
         )
 
         return text, fig
@@ -1022,13 +989,13 @@ HEADER = """
     <div>
       <h1 style="margin:0 0 4px;font-size:1.45rem;font-weight:900;
                  color:#E8EDF5;letter-spacing:.06em;font-family:monospace;">
-        EUR/USD &nbsp;·&nbsp; ENSEMBLE FORECAST ENGINE
+        EUR/USD &nbsp;·&nbsp; RIDGE FORECAST ENGINE
         <span style="color:#00FFB2;font-size:.85rem;margin-left:10px;
                      vertical-align:middle;letter-spacing:.12em;">ULTRA-PREMIUM</span>
       </h1>
       <p style="margin:0;color:#3A4A5E;font-size:.75rem;font-family:monospace;
                 letter-spacing:.04em;">
-        RIDGE+GBM ENSEMBLE · ATR-NORM TARGET · REGIME FILTER · SIGNAL THRESHOLD · 80+ FEATURES
+        STACKED RIDGE · POLYNOMIAL INTERACTIONS · RIDGECV ALPHA · 75+ FEATURES · ATR TP/SL
       </p>
     </div>
   </div>
@@ -1062,7 +1029,7 @@ HEADER = """
 #  GRADIO UI
 # ══════════════════════════════════════════════════════════════════════════════
 
-with gr.Blocks(css=CSS, title="EUR/USD Ensemble Forecast Engine") as app:
+with gr.Blocks(css=CSS, title="EUR/USD Ridge Forecast Engine") as app:
     gr.HTML(HEADER)
 
     with gr.Row(elem_classes="btn-row"):