Update app.py

app.py

@@ -1,64 +1,61 @@
 # ══════════════════════════════════════════════════════════════════════════════
-#  EUR/USD  ·  ENSEMBLE FORECAST ENGINE  ·  Premium Edition
-#  5 Model: Random Forest · Gradient Boosting · AdaBoost · Ridge · SVR
-#  TP/SL hesaplama · ATR tabanlı risk yönetimi · Backtest analizi
-#  Veri: Yahoo Finance (yfinance)
+#  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)
 # ══════════════════════════════════════════════════════════════════════════════
 
 import gradio as gr
 import pandas as pd
 import numpy as np
-from datetime import datetime, timedelta
+from datetime import datetime
 import yfinance as yf
-from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, AdaBoostRegressor
-from sklearn.linear_model import Ridge
-from sklearn.svm import SVR
-from sklearn.preprocessing import StandardScaler
+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
 import matplotlib
 matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 import matplotlib.patches as mpatches
 from matplotlib.gridspec import GridSpec
 import matplotlib.ticker as mticker
-from matplotlib.lines import Line2D
+from matplotlib.colors import LinearSegmentedColormap
 import traceback
 import warnings
 warnings.filterwarnings('ignore')
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  RENK PALETİ
+#  DESIGN TOKENS  (Obsidian / Phosphor palette)
 # ══════════════════════════════════════════════════════════════════════════════
-BG      = "#0A0E17"
-PANEL   = "#0F1623"
-PANEL2  = "#111827"
-BORDER  = "#1E293B"
-ACCENT  = "#3B82F6"
-ACCENT2 = "#6366F1"
-GREEN   = "#10B981"
-RED     = "#EF4444"
-AMBER   = "#F59E0B"
-PURPLE  = "#8B5CF6"
-PINK    = "#EC4899"
-MUTED   = "#64748B"
-TEXT    = "#F1F5F9"
-SUBTEXT = "#94A3B8"
-
-MODEL_COLORS = [ACCENT, PURPLE, GREEN, AMBER, PINK]
+BG      = "#080C12"
+PANEL   = "#0C1119"
+PANEL2  = "#10161F"
+BORDER  = "#1A2233"
+BORDER2 = "#243044"
+
+ACID    = "#00FFB2"       # phosphor-green accent — signature element
+ACID2   = "#00D4FF"       # cyan secondary
+ACID3   = "#7B61FF"       # violet tertiary
+WARM    = "#FF6B35"       # orange for SHORT signals
+WARN    = "#FFB800"       # amber for warnings
+RED     = "#FF3D5A"
+GREEN   = "#00E88F"
+MUTED   = "#3A4A5E"
+TEXT    = "#E8EDF5"
+SUBTEXT = "#6B7E99"
+DIM     = "#3A4A5E"
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  VERİ KATMANI
+#  DATA LAYER
 # ══════════════════════════════════════════════════════════════════════════════
 
-def get_forex_data(symbol: str = "EURUSD=X", period: str = "150d") -> pd.DataFrame | None:
-    """
-    Yahoo Finance'ten günlük OHLCV verisi indirir.
-    150 günlük pencere — SMA-50 ve lag-7 için yeterli.
-    """
+def get_forex_data(symbol: str = "EURUSD=X", period: str = "200d") -> pd.DataFrame | None:
     try:
         raw = yf.download(symbol, period=period, interval="1d", progress=False, auto_adjust=True)
-        if raw is None or len(raw) < 60:
+        if raw is None or len(raw) < 80:
             return None
-        # MultiIndex sütunlarını düzelt
         if isinstance(raw.columns, pd.MultiIndex):
             raw.columns = raw.columns.get_level_values(0)
         return raw
@@ -67,757 +64,832 @@ def get_forex_data(symbol: str = "EURUSD=X", period: str = "150d") -> pd.DataFra
 
 
 def compute_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
-    """True Range tabanlı ATR hesabı."""
-    high = df['High']
-    low  = df['Low']
-    prev_close = df['Close'].shift(1)
-    tr = pd.concat([
-        high - low,
-        (high - prev_close).abs(),
-        (low  - prev_close).abs(),
-    ], axis=1).max(axis=1)
+    high, low, prev_close = df['High'], df['Low'], df['Close'].shift(1)
+    tr = pd.concat([(high - low), (high - prev_close).abs(), (low - prev_close).abs()], axis=1).max(axis=1)
     return tr.rolling(period).mean()
 
 
 def compute_stoch(df: pd.DataFrame, k: int = 14, d: int = 3):
-    """Stochastic Oscillator %K ve %D."""
-    low_min  = df['Low'].rolling(k).min()
-    high_max = df['High'].rolling(k).max()
-    pct_k = 100 * (df['Close'] - low_min) / (high_max - low_min + 1e-10)
-    pct_d = pct_k.rolling(d).mean()
-    return pct_k, pct_d
+    lmin = df['Low'].rolling(k).min()
+    hmax = df['High'].rolling(k).max()
+    pct_k = 100 * (df['Close'] - lmin) / (hmax - lmin + 1e-10)
+    return pct_k, pct_k.rolling(d).mean()
 
 
 def compute_cci(df: pd.DataFrame, period: int = 20) -> pd.Series:
-    """Commodity Channel Index."""
-    tp  = (df['High'] + df['Low'] + df['Close']) / 3
+    tp = (df['High'] + df['Low'] + df['Close']) / 3
     sma = tp.rolling(period).mean()
     mad = tp.rolling(period).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
     return (tp - sma) / (0.015 * mad + 1e-10)
 
 
 def compute_williams_r(df: pd.DataFrame, period: int = 14) -> pd.Series:
-    """Williams %R."""
-    high_max = df['High'].rolling(period).max()
-    low_min  = df['Low'].rolling(period).min()
-    return -100 * (high_max - df['Close']) / (high_max - low_min + 1e-10)
+    hmax = df['High'].rolling(period).max()
+    lmin = df['Low'].rolling(period).min()
+    return -100 * (hmax - df['Close']) / (hmax - lmin + 1e-10)
+
+
+def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
+    delta = series.diff()
+    gain = delta.where(delta > 0, 0.0).rolling(period).mean()
+    loss = (-delta.where(delta < 0, 0.0)).rolling(period).mean()
+    return 100 - (100 / (1 + gain / (loss + 1e-10)))
 
 
 def create_features(data: pd.DataFrame) -> pd.DataFrame:
     """
-    22 teknik gösterge + 7 lag feature üretir.
-    Toplam: 29 input feature.
+    Premium feature set — 55+ engineered features designed to minimise MAE
+    for Ridge regression via diverse, low-noise signal construction.
     """
     df = data.copy()
 
-    # ── Temel getiri & mum özellikleri ───────────────────────────────────────
-    df['Returns']       = df['Close'].pct_change()
-    df['Log_Returns']   = np.log(df['Close'] / df['Close'].shift(1))
-    df['High_Low']      = df['High'] - df['Low']
-    df['Close_Open']    = df['Close'] - df['Open']
-    df['Body_Ratio']    = df['Close_Open'].abs() / (df['High_Low'] + 1e-10)
-    df['Upper_Shadow']  = df['High'] - df[['Close', 'Open']].max(axis=1)
-    df['Lower_Shadow']  = df[['Close', 'Open']].min(axis=1) - df['Low']
-
-    # ── Hareketli ortalamalar ─────────────────────────────────────────────────
-    for w in [5, 10, 20, 50]:
+    # ── Price action ─────────────────────────────────────────────────────────
+    df['Returns']      = df['Close'].pct_change()
+    df['Log_Returns']  = np.log(df['Close'] / df['Close'].shift(1))
+    df['High_Low']     = df['High'] - df['Low']
+    df['Close_Open']   = df['Close'] - df['Open']
+    df['Body_Ratio']   = df['Close_Open'].abs() / (df['High_Low'] + 1e-10)
+    df['Upper_Shadow'] = df['High'] - df[['Close', 'Open']].max(axis=1)
+    df['Lower_Shadow'] = df[['Close', 'Open']].min(axis=1) - df['Low']
+    df['HL_to_Close']  = df['High_Low'] / (df['Close'] + 1e-10)
+
+    # ── Moving averages & crosses ─────────────────────────────────────────────
+    for w in [3, 5, 8, 13, 21, 34, 55]:   # Fibonacci periods
         df[f'SMA_{w}']  = df['Close'].rolling(w).mean()
         df[f'EMA_{w}']  = df['Close'].ewm(span=w, adjust=False).mean()
 
-    # SMA mesafe oranları
-    df['Price_SMA5_Ratio']  = df['Close'] / df['SMA_5']
-    df['Price_SMA20_Ratio'] = df['Close'] / df['SMA_20']
-    df['SMA5_SMA20_Cross']  = df['SMA_5'] - df['SMA_20']
+    df['Price_SMA3_Ratio']  = df['Close'] / (df['SMA_3']  + 1e-10)
+    df['Price_SMA8_Ratio']  = df['Close'] / (df['SMA_8']  + 1e-10)
+    df['Price_SMA21_Ratio'] = df['Close'] / (df['SMA_21'] + 1e-10)
+    df['Price_SMA55_Ratio'] = df['Close'] / (df['SMA_55'] + 1e-10)
+
+    df['SMA3_SMA21_Cross']  = df['SMA_3']  - df['SMA_21']
+    df['SMA8_SMA34_Cross']  = df['SMA_8']  - df['SMA_34']
+    df['EMA3_EMA21_Cross']  = df['EMA_3']  - df['EMA_21']
+    df['EMA8_EMA55_Cross']  = df['EMA_8']  - df['EMA_55']
 
-    # ── RSI ───────────────────────────────────────────────────────────────────
-    delta = df['Close'].diff()
-    gain  = delta.where(delta > 0, 0.0).rolling(14).mean()
-    loss  = (-delta.where(delta < 0, 0.0)).rolling(14).mean()
-    rs    = gain / (loss + 1e-10)
-    df['RSI'] = 100 - (100 / (1 + rs))
+    # Price distance from key MA levels (mean-reversion signal)
+    df['Dist_SMA21'] = (df['Close'] - df['SMA_21']) / (df['SMA_21'] + 1e-10)
+    df['Dist_SMA55'] = (df['Close'] - df['SMA_55']) / (df['SMA_55'] + 1e-10)
 
-    # ── MACD ──────────────────────────────────────────────────────────────────
+    # ── RSI multi-period ──────────────────────────────────────────────────────
+    for p in [7, 14, 21]:
+        df[f'RSI_{p}'] = compute_rsi(df['Close'], p)
+
+    df['RSI_Divergence'] = df['RSI_7'] - df['RSI_21']
+
+    # ── MACD variants ─────────────────────────────────────────────────────────
     ema12 = df['Close'].ewm(span=12, adjust=False).mean()
     ema26 = df['Close'].ewm(span=26, adjust=False).mean()
     df['MACD']        = ema12 - ema26
     df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
     df['MACD_Hist']   = df['MACD'] - df['MACD_Signal']
+    df['MACD_Norm']   = df['MACD'] / (df['Close'] + 1e-10)   # normalised
+
+    # Short MACD (5/13/3) for faster signals
+    ema5  = df['Close'].ewm(span=5,  adjust=False).mean()
+    ema13 = df['Close'].ewm(span=13, adjust=False).mean()
+    df['MACD_Fast']     = ema5  - ema13
+    df['MACD_Fast_Sig'] = df['MACD_Fast'].ewm(span=3, adjust=False).mean()
+    df['MACD_Fast_Hist']= df['MACD_Fast'] - df['MACD_Fast_Sig']
+
+    # ── Bollinger Bands (multi-period) ────────────────────────────────────────
+    for w in [20, 10]:
+        mid = df['Close'].rolling(w).mean()
+        std = df['Close'].rolling(w).std()
+        df[f'BB_upper_{w}'] = mid + std * 2
+        df[f'BB_lower_{w}'] = mid - std * 2
+        df[f'BB_width_{w}'] = (df[f'BB_upper_{w}'] - df[f'BB_lower_{w}']) / (mid + 1e-10)
+        df[f'BB_pct_{w}']   = (df['Close'] - df[f'BB_lower_{w}']) / (
+                               df[f'BB_upper_{w}'] - df[f'BB_lower_{w}'] + 1e-10)
+
+    # ── ATR & volatility ──────────────────────────────────────────────────────
+    df['ATR']       = compute_atr(df, 14)
+    df['ATR_7']     = compute_atr(df, 7)
+    df['ATR_Pct']   = df['ATR'] / (df['Close'] + 1e-10)
+    df['ATR_Ratio'] = df['ATR_7'] / (df['ATR'] + 1e-10)   # short/long vol ratio
+
+    df['Vol_5']   = df['Returns'].rolling(5).std()
+    df['Vol_10']  = df['Returns'].rolling(10).std()
+    df['Vol_20']  = df['Returns'].rolling(20).std()
+    df['Vol_Ratio'] = df['Vol_5'] / (df['Vol_20'] + 1e-10)
+
+    # ── Stochastic + CCI + Williams ───────────────────────────────────────────
+    df['Stoch_K'], df['Stoch_D'] = compute_stoch(df, 14, 3)
+    df['Stoch_K_5'], df['Stoch_D_5'] = compute_stoch(df, 5, 3)
+    df['Stoch_Cross']  = df['Stoch_K'] - df['Stoch_D']
+    df['CCI']          = compute_cci(df, 20)
+    df['CCI_10']       = compute_cci(df, 10)
+    df['WilliamsR']    = compute_williams_r(df, 14)
+    df['WilliamsR_7']  = compute_williams_r(df, 7)
+
+    # ── Momentum (Rate of Change) ─────────────────────────────────────────────
+    for p in [3, 5, 10, 20]:
+        df[f'ROC_{p}'] = df['Close'].pct_change(p)
+
+    # ── Trend strength ────────────────────────────────────────────────────────
+    df['ADX_Proxy'] = (df['Returns'].rolling(14).std() /
+                       df['Returns'].rolling(14).mean().abs().clip(lower=1e-10))
+
+    # ── Lag features (close price) ────────────────────────────────────────────
+    for i in range(1, 11):
+        df[f'Lag_{i}'] = df['Close'].shift(i)
 
-    # ── Bollinger Bantları ────────────────────────────────────────────────────
-    df['BB_middle'] = df['Close'].rolling(20).mean()
-    df['BB_std']    = df['Close'].rolling(20).std()
-    df['BB_upper']  = df['BB_middle'] + df['BB_std'] * 2
-    df['BB_lower']  = df['BB_middle'] - df['BB_std'] * 2
-    df['BB_width']  = (df['BB_upper'] - df['BB_lower']) / (df['BB_middle'] + 1e-10)
-    df['BB_pct']    = (df['Close'] - df['BB_lower']) / (df['BB_upper'] - df['BB_lower'] + 1e-10)
-
-    # ── ATR ───────────────────────────────────────────────��───────────────────
-    df['ATR']     = compute_atr(df, 14)
-    df['ATR_Pct'] = df['ATR'] / df['Close']
-
-    # ── Stochastic ────────────────────────────────────────────────────────────
-    df['Stoch_K'], df['Stoch_D'] = compute_stoch(df)
-
-    # ── CCI ───────────────────────────────────────────────────────────────────
-    df['CCI'] = compute_cci(df, 20)
-
-    # ── Williams %R ───────────────────────────────────────────────────────────
-    df['WilliamsR'] = compute_williams_r(df, 14)
-
-    # ── Volatilite ────────────────────────────────────────────────────────────
-    df['Volatility_5']  = df['Returns'].rolling(5).std()
-    df['Volatility_20'] = df['Returns'].rolling(20).std()
-
-    # ── Volume (varsa) ────────────────────────────────────────────────────────
-    if 'Volume' in df.columns:
-        df['Volume_MA']    = df['Volume'].rolling(10).mean()
-        df['Volume_Ratio'] = df['Volume'] / (df['Volume_MA'] + 1e-10)
+    # ── Lag returns ───────────────────────────────────────────────────────────
+    for i in range(1, 6):
+        df[f'LagRet_{i}'] = df['Returns'].shift(i)
+
+    # ── Rolling statistics ────────────────────────────────────────────────────
+    df['Close_Min5']  = df['Close'].rolling(5).min()
+    df['Close_Max5']  = df['Close'].rolling(5).max()
+    df['Close_Min20'] = df['Close'].rolling(20).min()
+    df['Close_Max20'] = df['Close'].rolling(20).max()
+    df['Range_Pct5']  = (df['Close'] - df['Close_Min5']) / (df['Close_Max5']  - df['Close_Min5']  + 1e-10)
+    df['Range_Pct20'] = (df['Close'] - df['Close_Min20']) / (df['Close_Max20'] - df['Close_Min20'] + 1e-10)
+
+    # ── Volume ────────────────────────────────────────────────────────────────
+    if 'Volume' in df.columns and df['Volume'].sum() > 0:
+        df['Vol_MA10']    = df['Volume'].rolling(10).mean()
+        df['Volume_Ratio']= df['Volume'] / (df['Vol_MA10'] + 1e-10)
+        df['OBV']         = (np.sign(df['Returns']) * df['Volume']).cumsum()
+        df['OBV_MA']      = df['OBV'].rolling(10).mean()
+        df['OBV_Signal']  = (df['OBV'] - df['OBV_MA']) / (df['OBV_MA'].abs() + 1e-10)
     else:
-        df['Volume_MA']    = 0.0
         df['Volume_Ratio'] = 1.0
-
-    # ── Lag features ──────────────────────────────────────────────────────────
-    for i in range(1, 8):
-        df[f'Lag_{i}'] = df['Close'].shift(i)
+        df['OBV_Signal']   = 0.0
 
     return df.dropna()
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  FEATURE KOLONLARI
+#  FEATURE COLUMNS
 # ══════════════════════════════════════════════════════════════════════════════
 FEATURE_COLS = [
-    # Temel
+    # Price action
     'Returns', 'Log_Returns', 'High_Low', 'Close_Open',
-    'Body_Ratio', 'Upper_Shadow', 'Lower_Shadow',
-    # SMA / EMA
-    'SMA_5', 'SMA_10', 'SMA_20', 'SMA_50',
-    'EMA_5', 'EMA_10', 'EMA_20',
-    'Price_SMA5_Ratio', 'Price_SMA20_Ratio', 'SMA5_SMA20_Cross',
+    'Body_Ratio', 'Upper_Shadow', 'Lower_Shadow', 'HL_to_Close',
+    # Moving averages
+    'SMA_3', 'SMA_5', 'SMA_8', 'SMA_13', 'SMA_21', 'SMA_34', 'SMA_55',
+    'EMA_3', 'EMA_5', 'EMA_8', 'EMA_13', 'EMA_21', 'EMA_34', 'EMA_55',
+    'Price_SMA3_Ratio', 'Price_SMA8_Ratio', 'Price_SMA21_Ratio', 'Price_SMA55_Ratio',
+    'SMA3_SMA21_Cross', 'SMA8_SMA34_Cross', 'EMA3_EMA21_Cross', 'EMA8_EMA55_Cross',
+    'Dist_SMA21', 'Dist_SMA55',
+    # RSI
+    'RSI_7', 'RSI_14', 'RSI_21', 'RSI_Divergence',
+    # MACD
+    'MACD', 'MACD_Signal', 'MACD_Hist', 'MACD_Norm',
+    'MACD_Fast', 'MACD_Fast_Sig', 'MACD_Fast_Hist',
+    # Bollinger
+    'BB_width_20', 'BB_pct_20', 'BB_width_10', 'BB_pct_10',
+    # ATR & volatility
+    'ATR', 'ATR_7', 'ATR_Pct', 'ATR_Ratio',
+    'Vol_5', 'Vol_10', 'Vol_20', 'Vol_Ratio',
+    # Oscillators
+    'Stoch_K', 'Stoch_D', 'Stoch_K_5', 'Stoch_D_5', 'Stoch_Cross',
+    'CCI', 'CCI_10', 'WilliamsR', 'WilliamsR_7',
     # Momentum
-    'RSI', 'MACD', 'MACD_Signal', 'MACD_Hist',
-    'Stoch_K', 'Stoch_D', 'CCI', 'WilliamsR',
-    # Volatilite / BB
-    'BB_middle', 'BB_upper', 'BB_lower', 'BB_width', 'BB_pct',
-    'ATR', 'ATR_Pct',
-    'Volatility_5', 'Volatility_20',
+    'ROC_3', 'ROC_5', 'ROC_10', 'ROC_20', 'ADX_Proxy',
+    # Lag close
+    'Lag_1', 'Lag_2', 'Lag_3', 'Lag_4', 'Lag_5',
+    'Lag_6', 'Lag_7', 'Lag_8', 'Lag_9', 'Lag_10',
+    # Lag returns
+    'LagRet_1', 'LagRet_2', 'LagRet_3', 'LagRet_4', 'LagRet_5',
+    # Range
+    'Range_Pct5', 'Range_Pct20',
     # Volume
-    'Volume_Ratio',
-    # Lag
-    'Lag_1', 'Lag_2', 'Lag_3', 'Lag_4', 'Lag_5', 'Lag_6', 'Lag_7',
+    'Volume_Ratio', 'OBV_Signal',
 ]
 
+
 # ══════════════════════════════════════════════════════════════════════════════
-#  MODEL KATMANI
+#  RIDGE MODEL LAYER
+#  Strategy: stacked multi-target Ridge with optimised alpha via RidgeCV
+#  + second-order interaction features for non-linear capture
 # ══════════════════════════════════════════════════════════════════════════════
 
-def build_models() -> dict:
-    """Her çağrıda taze model örnekleri döndürür (paralel eğitim güvenliği)."""
-    return {
-        'Random Forest':     RandomForestRegressor(
-                                 n_estimators=300, max_depth=12,
-                                 min_samples_leaf=3, random_state=42, n_jobs=-1),
-        'Gradient Boosting': GradientBoostingRegressor(
-                                 n_estimators=300, learning_rate=0.04,
-                                 max_depth=5, subsample=0.8, random_state=42),
-        'AdaBoost':          AdaBoostRegressor(
-                                 n_estimators=200, learning_rate=0.08, random_state=42),
-        'Ridge':             Ridge(alpha=0.3),
-        'SVR':               SVR(kernel='rbf', C=500, gamma='scale', epsilon=0.00005),
-    }
-
-
-def train_and_evaluate(df: pd.DataFrame):
+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)),   # 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).
     """
-    Modelleri eğitir; son 10 günü test seti olarak kullanır.
-    Hedef: yarınki kapanış - bugünkü kapanış (fiyat değişimi / delta).
-    Bu sayede Ridge dahil tüm modeller mutlak fiyata yakınsamak yerine
-    gerçek yön ve büyüklük sinyali öğrenir.
-    Dönüş: trained_models, scaler, test_preds (mutlak fiyat), y_test (mutlak fiyat), avail
+    alphas = np.logspace(-3, 4, 60)
+    scaler = StandardScaler()
+    Xs = scaler.fit_transform(X_tr)
+    rcv = RidgeCV(alphas=alphas, cv=5, scoring='neg_mean_absolute_error')
+    rcv.fit(Xs, y_tr)
+    return float(rcv.alpha_)
+
+
+def train_ridge(df: pd.DataFrame, horizon: int = 1):
+    """
+    Trains the premium Ridge model.
+    Target: price delta after `horizon` days.
+    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
 
-    # Hedef: bir sonraki günün fiyat değişimi (delta)
-    y_delta      = np.diff(close)       # uzunluk = N-1
-    X            = X[:-1]              # son satırı at (yarını bilinmiyor)
-    close_aligned = close[:-1]         # delta ile hizalı kapanışlar
+    # Build delta target aligned to horizon
+    y_delta        = np.zeros(len(close) - horizon)
+    for h in range(1, horizon + 1):
+        y_delta += close[h:len(close) - horizon + h] - close[:len(close) - horizon]
+    y_delta /= horizon   # average delta per day (smoother target)
+
+    X = X[:len(y_delta)]
+    close_aligned = close[:len(y_delta)]
 
-    split = -10
-    X_train, X_test       = X[:split],            X[split:]
-    y_train, y_delta_test = y_delta[:split],       y_delta[split:]
+    split = -15   # 15-day test window for robust backtest
+    X_train, X_test       = X[:split],           X[split:]
+    y_train, y_delta_test = y_delta[:split],      y_delta[split:]
     close_test            = close_aligned[split:]
 
-    scaler  = StandardScaler()
-    X_tr_sc = scaler.fit_transform(X_train)
-    X_te_sc = scaler.transform(X_test)
+    # Find best alpha on training data only
+    best_alpha = select_best_alpha(X_train, y_train)
 
-    models     = build_models()
-    trained    = {}
-    test_preds = {}   # grafik/metrik uyumu için mutlak fiyat olarak sakla
+    # Build & fit pipeline
+    pipe = build_ridge_pipeline(best_alpha)
+    pipe.fit(X_train, y_train)
 
-    for name, m in models.items():
-        m.fit(X_tr_sc, y_train)
-        delta_pred         = m.predict(X_te_sc)
-        test_preds[name]   = close_test + delta_pred   # delta → mutlak fiyat
-        trained[name]      = m
+    # Test predictions → absolute price
+    delta_hat  = pipe.predict(X_test)
+    pred_abs   = close_test + delta_hat
+    y_test_abs = close_test + y_delta_test
 
-    y_test = close_test + y_delta_test   # gerçek mutlak fiyat (backtest için)
+    mae  = mean_absolute_error(y_test_abs, pred_abs)
 
-    return trained, scaler, test_preds, y_test, avail
+    return pipe, pred_abs, y_test_abs, avail, best_alpha, mae
 
 
-def predict_next(trained: dict, scaler, df: pd.DataFrame, avail: list):
-    """
-    Son satırın feature'larından ertesi gün tahmini üretir.
-    Model delta (değişim) tahmin eder; mevcut kapanışa eklenerek
-    mutlak fiyata dönüştürülür.
-    """
+def predict_next_ridge(pipe, df: pd.DataFrame, avail: list,
+                       horizon: int = 1) -> float:
+    """Predict absolute close price horizon days ahead."""
     cp = float(df['Close'].iloc[-1])
     x  = df[avail].iloc[-1].values.reshape(1, -1)
-    xs = scaler.transform(x)
-    preds    = {n: cp + float(m.predict(xs)[0]) for n, m in trained.items()}
-    ensemble = float(np.mean(list(preds.values())))
-    return preds, ensemble
+    delta = float(pipe.predict(x)[0])
+    return cp + delta * horizon
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  TP / SL HESAPLAMA  (ATR tabanlı risk yönetimi)
+#  TP / SL  (ATR-based)
 # ══════════════════════════════════════════════════════════════════════════════
 
-def compute_tp_sl(
-    current_price: float,
-    ensemble_pred: float,
-    atr: float,
-    atr_multiplier_sl: float = 1.5,
-    rr_ratio: float = 2.0,
-) -> dict:
-    """
-    ATR tabanlı TP / SL hesaplar.
+def compute_tp_sl(current_price, pred_price, atr,
+                  atr_multiplier_sl=1.5, rr_ratio=2.0) -> dict:
+    direction = "LONG" if pred_price > current_price else "SHORT"
+    sl_dist   = atr * atr_multiplier_sl
+    tp_dist   = sl_dist * rr_ratio
+    pip       = 0.0001
 
-    Yön:  ensemble > current → LONG  |  ensemble < current → SHORT
+    if direction == "LONG":
+        sl, tp = current_price - sl_dist, current_price + tp_dist
+    else:
+        sl, tp = current_price + sl_dist, current_price - tp_dist
 
-    SL = current ± (ATR × atr_multiplier_sl)
-    TP = current ± (|SL mesafesi| × rr_ratio)
+    return dict(
+        direction=direction, entry=current_price, sl=sl, tp=tp,
+        sl_pips=sl_dist/pip, tp_pips=tp_dist/pip,
+        rr=rr_ratio, risk_pct=(sl_dist/current_price)*100, atr=atr,
+    )
 
-    Dönüş: direction, entry, sl, tp, sl_pips, tp_pips, rr, risk_pct
-    """
-    direction  = "LONG" if ensemble_pred > current_price else "SHORT"
-    sl_dist    = atr * atr_multiplier_sl
-    tp_dist    = sl_dist * rr_ratio
 
-    if direction == "LONG":
-        sl = current_price - sl_dist
-        tp = current_price + tp_dist
-    else:
-        sl = current_price + sl_dist
-        tp = current_price - tp_dist
-
-    pip_size  = 0.0001          # EUR/USD standart pip
-    sl_pips   = sl_dist / pip_size
-    tp_pips   = tp_dist / pip_size
-    risk_pct  = (sl_dist / current_price) * 100
-
-    return {
-        'direction' : direction,
-        'entry'     : current_price,
-        'sl'        : sl,
-        'tp'        : tp,
-        'sl_pips'   : sl_pips,
-        'tp_pips'   : tp_pips,
-        'rr'        : rr_ratio,
-        'risk_pct'  : risk_pct,
-        'atr'       : atr,
-    }
-
-
-def compute_signal_score(df: pd.DataFrame, direction: str) -> dict:
-    """
-    RSI · MACD · Stoch · CCI · BB pozisyonuna bakarak
-    sinyal gücünü 0–100 arasında puanlar.
-    """
-    row     = df.iloc[-1]
-    score   = 0
-    details = {}
+def signal_score(df: pd.DataFrame, direction: str) -> dict:
+    row   = df.iloc[-1]
+    score = 0
+    det   = {}
 
-    rsi = float(row['RSI'])
+    rsi = float(row.get('RSI_14', 50))
     if direction == "LONG":
-        if rsi < 70:
-            pts = max(0, (70 - rsi) / 70 * 25)
-            score += pts
-            details['RSI'] = f"{rsi:.1f} — boğa bölgesi  (+{pts:.0f}p)"
-        else:
-            details['RSI'] = f"{rsi:.1f} — aşırı alım  (0p)"
+        pts = max(0, (70 - rsi) / 70 * 25) if rsi < 70 else 0
     else:
-        if rsi > 30:
-            pts = max(0, (rsi - 30) / 70 * 25)
-            score += pts
-            details['RSI'] = f"{rsi:.1f} — ayı bölgesi  (+{pts:.0f}p)"
-        else:
-            details['RSI'] = f"{rsi:.1f} — aşırı satım  (0p)"
-
-    macd = float(row['MACD'])
-    mhist = float(row['MACD_Hist'])
+        pts = max(0, (rsi - 30) / 70 * 25) if rsi > 30 else 0
+    score += pts; det['RSI-14'] = f"{rsi:.1f}  (+{pts:.0f}p)"
+
+    macd  = float(row.get('MACD', 0))
+    mhist = float(row.get('MACD_Hist', 0))
     if direction == "LONG":
         pts = 20 if (macd > 0 and mhist > 0) else (10 if macd > 0 else 0)
     else:
         pts = 20 if (macd < 0 and mhist < 0) else (10 if macd < 0 else 0)
-    score += pts
-    details['MACD'] = f"macd={macd:.5f}  hist={mhist:.5f}  (+{pts}p)"
+    score += pts; det['MACD'] = f"{macd:.5f}  hist={mhist:.5f}  (+{pts}p)"
 
-    stk = float(row['Stoch_K'])
-    std = float(row['Stoch_D'])
+    stk = float(row.get('Stoch_K', 50))
+    std = float(row.get('Stoch_D', 50))
     if direction == "LONG":
         pts = 20 if (stk < 80 and stk > std) else (10 if stk < 80 else 0)
     else:
         pts = 20 if (stk > 20 and stk < std) else (10 if stk > 20 else 0)
-    score += pts
-    details['Stoch'] = f"K={stk:.1f}  D={std:.1f}  (+{pts}p)"
+    score += pts; det['Stoch'] = f"K={stk:.1f} D={std:.1f}  (+{pts}p)"
 
-    cci = float(row['CCI'])
-    if direction == "LONG":
-        pts = 20 if cci > -100 else 5
-    else:
-        pts = 20 if cci < 100 else 5
-    score += pts
-    details['CCI'] = f"{cci:.1f}  (+{pts}p)"
+    cci = float(row.get('CCI', 0))
+    pts = 20 if (direction=="LONG" and cci > -100) or (direction=="SHORT" and cci < 100) else 5
+    score += pts; det['CCI'] = f"{cci:.1f}  (+{pts}p)"
 
-    bb_pct = float(row['BB_pct'])
-    if direction == "LONG":
-        pts = 15 if bb_pct < 0.5 else 5
-    else:
-        pts = 15 if bb_pct > 0.5 else 5
-    score += pts
-    details['BB%'] = f"{bb_pct:.2f}  (+{pts}p)"
+    bb = float(row.get('BB_pct_20', 0.5))
+    pts = 15 if (direction=="LONG" and bb < 0.5) or (direction=="SHORT" and bb > 0.5) else 5
+    score += pts; det['BB%'] = f"{bb:.3f}  (+{pts}p)"
 
-    label = ("GÜÇLÜ ✅" if score >= 75
-             else "ORTA ⚠" if score >= 45
-             else "ZAYIF ❌")
-
-    return {'score': min(100, score), 'label': label, 'details': details}
+    label = "GÜÇLÜ ✅" if score >= 75 else ("ORTA ⚠️" if score >= 45 else "ZAYIF ❌")
+    return {'score': min(100, score), 'label': label, 'details': det}
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  GRAFİK MOTORU
+#  CHART ENGINE  — phosphor-green terminal aesthetic
 # ══════════════════════════════════════════════════════════════════════════════
 
-def _set_ax_style(ax, title: str = "", ylabel: str = ""):
+def _ax_style(ax, title="", ylabel=""):
     ax.set_facecolor(PANEL)
     ax.tick_params(colors=SUBTEXT, labelsize=7)
     for spine in ax.spines.values():
-        spine.set_edgecolor(BORDER)
-    ax.grid(True, color=BORDER, linewidth=0.4, alpha=0.6)
+        spine.set_edgecolor(BORDER2)
+        spine.set_linewidth(0.6)
+    ax.grid(True, color=BORDER, linewidth=0.35, alpha=0.7, linestyle=':')
     if title:
-        ax.set_title(title, fontsize=8.5, color=TEXT, pad=7, loc='left', fontweight='bold')
+        ax.set_title(title, fontsize=8, color=TEXT, pad=6, loc='left',
+                     fontfamily='monospace', fontweight='bold')
     if ylabel:
-        ax.set_ylabel(ylabel, fontsize=7, color=SUBTEXT)
+        ax.set_ylabel(ylabel, fontsize=6.5, color=SUBTEXT, fontfamily='monospace')
 
 
-def build_figure(
-    df: pd.DataFrame,
-    next_preds: dict,
-    ensemble_pred: float,
-    test_preds: dict,
-    y_test: np.ndarray,
-    tp_sl: dict,
-) -> plt.Figure:
+def build_figure(df, pred_price, horizon, tp_sl,
+                 test_pred_abs, y_test_abs, best_alpha, mae) -> plt.Figure:
 
     plt.rcParams.update({
-        'font.family' : 'monospace',
-        'text.color'  : TEXT,
-        'figure.facecolor': BG,
-        'axes.facecolor'  : PANEL,
-        'axes.edgecolor'  : BORDER,
-        'grid.color'      : BORDER,
-        'grid.linewidth'  : 0.4,
+        'font.family':       'monospace',
+        'text.color':        TEXT,
+        'figure.facecolor':  BG,
+        'axes.facecolor':    PANEL,
+        'axes.edgecolor':    BORDER2,
+        'grid.color':        BORDER,
+        'grid.linewidth':    0.35,
     })
 
-    fig = plt.figure(figsize=(16, 15))
-    gs  = GridSpec(4, 2, figure=fig, hspace=0.52, wspace=0.32,
-                   left=0.06, right=0.97, top=0.94, bottom=0.04)
+    fig = plt.figure(figsize=(17, 16))
+    gs  = GridSpec(5, 2, figure=fig,
+                   hspace=0.55, wspace=0.30,
+                   left=0.055, right=0.97, top=0.93, bottom=0.04)
 
-    ax_price  = fig.add_subplot(gs[0, :])    # Fiyat + BB + TP/SL
-    ax_rsi    = fig.add_subplot(gs[1, 0])    # RSI
-    ax_macd   = fig.add_subplot(gs[1, 1])    # MACD
-    ax_stoch  = fig.add_subplot(gs[2, 0])    # Stochastic
-    ax_cci    = fig.add_subplot(gs[2, 1])    # CCI
-    ax_models = fig.add_subplot(gs[3, :])    # Model karşılaştırması
+    ax_price  = fig.add_subplot(gs[0:2, :])   # tall price chart
+    ax_rsi    = fig.add_subplot(gs[2, 0])
+    ax_macd   = fig.add_subplot(gs[2, 1])
+    ax_stoch  = fig.add_subplot(gs[3, 0])
+    ax_cci    = fig.add_subplot(gs[3, 1])
+    ax_back   = fig.add_subplot(gs[4, :])     # backtest accuracy
 
-    tail = df.tail(50)
+    tail = df.tail(60)
     idx  = np.arange(len(tail))
     cp   = float(df['Close'].iloc[-1])
-
-    # ── PANEL 1: Fiyat + BB + TP/SL ─────────────────────────────────────────
-    _set_ax_style(ax_price, 'EUR/USD  ·  Son 50 Gün  +  Sonraki Gün Tahmini  (TP/SL)', 'Fiyat')
-    ax_price.fill_between(idx,
-        tail['BB_lower'].values, tail['BB_upper'].values,
-        alpha=0.07, color=ACCENT)
-    ax_price.plot(idx, tail['BB_upper'].values, lw=0.6, color=ACCENT, alpha=0.35, ls='--')
-    ax_price.plot(idx, tail['BB_lower'].values, lw=0.6, color=ACCENT, alpha=0.35, ls='--')
-    ax_price.plot(idx, tail['BB_middle'].values, lw=0.7, color=ACCENT, alpha=0.5, ls=':')
-    ax_price.plot(idx, tail['Close'].values,  lw=1.8, color=TEXT,  label='Kapanış', zorder=5)
-    ax_price.plot(idx, tail['SMA_20'].values, lw=1.0, color=AMBER, alpha=0.8, label='SMA 20', ls='--')
-    ax_price.plot(idx, tail['SMA_50'].values, lw=1.0, color=MUTED, alpha=0.7, label='SMA 50', ls=':')
-
-    # TP / SL yatay çizgiler
-    last_x = len(idx) - 1
-    ax_price.axhline(y=tp_sl['tp'], color=GREEN, lw=1.3, ls='--', alpha=0.9, zorder=4)
-    ax_price.axhline(y=tp_sl['sl'], color=RED,   lw=1.3, ls='--', alpha=0.9, zorder=4)
-    ax_price.axhline(y=cp,          color=TEXT,  lw=0.7, ls='-',  alpha=0.4, zorder=3)
-
-    r_margin = len(idx) * 0.02
-    ax_price.text(last_x + r_margin, tp_sl['tp'],
-                  f" TP {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f}p)",
-                  color=GREEN, fontsize=7.5, va='center', fontweight='bold')
-    ax_price.text(last_x + r_margin, tp_sl['sl'],
-                  f" SL {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f}p)",
-                  color=RED, fontsize=7.5, va='center', fontweight='bold')
-    ax_price.text(last_x + r_margin, cp,
-                  f" GİRİŞ {cp:.5f}",
-                  color=TEXT, fontsize=7.5, va='center')
-
-    # Ensemble ok
+    last = len(idx) - 1
+
+    # ── PRICE + BB + TP/SL ───────────────────────────────────────────────────
+    _ax_style(ax_price,
+              f'EUR/USD  ·  60-Day Close  +  Ridge Forecast  (Horizon: +{horizon}D)',
+              'Price')
+
+    # BB bands (glow effect)
+    for alpha_fill, mul in [(0.04, 2.5), (0.07, 2.0), (0.10, 1.0)]:
+        mid  = tail['SMA_21'].values
+        std_ = df['Close'].rolling(20).std().tail(60).values
+        ax_price.fill_between(idx, mid - std_*mul, mid + std_*mul,
+                               alpha=alpha_fill, color=ACID2, zorder=1)
+
+    ax_price.plot(idx, tail['SMA_21'].values,  lw=0.8, color=ACID2,  alpha=0.5, ls='--', zorder=2)
+    ax_price.plot(idx, tail['SMA_55'].values,  lw=0.8, color=MUTED,  alpha=0.6, ls=':',  zorder=2)
+
+    # Candlestick-style OHLC bars
+    for i, (_, row) in enumerate(tail.iterrows()):
+        o, h, l, c = float(row['Open']), float(row['High']), float(row['Low']), float(row['Close'])
+        color = GREEN if c >= o else WARM
+        ax_price.plot([i, i], [l, h], color=color, lw=0.6, alpha=0.5, zorder=3)
+        ax_price.add_patch(mpatches.FancyBboxPatch(
+            (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))
+
+    # Close line overlay (phosphor glow)
+    ax_price.plot(idx, tail['Close'].values, lw=1.6, color=ACID, zorder=5, alpha=0.9, label='Close')
+
+    # TP / SL / Entry lines
+    ax_price.axhline(tp_sl['tp'], color=GREEN, lw=1.4, ls='--', alpha=0.9, zorder=6)
+    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)
+
+    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),
+        (tp_sl['sl'], f"SL {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f}p)", RED),
+        (cp,          f"ENTRY {cp:.5f}",                                     TEXT),
+    ]:
+        ax_price.text(last + r, val, f"  {lbl}", color=col,
+                      fontsize=7.5, va='center', fontweight='bold', zorder=7)
+
+    # Forecast arrow
     ax_price.annotate(
-        f"► ENS {ensemble_pred:.5f}",
-        xy=(last_x, cp),
-        xytext=(last_x + len(idx) * 0.04, ensemble_pred),
-        arrowprops=dict(arrowstyle='->', color=ACCENT2, lw=1.4, connectionstyle='arc3,rad=0.2'),
-        color=ACCENT2, fontsize=8, fontweight='bold', zorder=6,
+        f"▶ +{horizon}D  {pred_price:.5f}",
+        xy=(last, cp),
+        xytext=(last + len(idx)*0.05, pred_price),
+        arrowprops=dict(arrowstyle='->', color=ACID, lw=1.6,
+                        connectionstyle='arc3,rad=0.25'),
+        color=ACID, fontsize=9, fontweight='bold', zorder=8,
+        fontfamily='monospace',
     )
 
-    ax_price.legend(fontsize=7, framealpha=0.15, labelcolor=SUBTEXT, ncol=5, loc='upper left')
+    ax_price.legend(fontsize=7, framealpha=0.1, labelcolor=SUBTEXT,
+                    ncol=3, loc='upper left')
     ax_price.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
 
-    # ── PANEL 2: RSI ─────────────────────────────────────────────────────────
-    _set_ax_style(ax_rsi, 'RSI (14)', 'RSI')
-    rsi_v = tail['RSI'].values
-    ax_rsi.plot(idx, rsi_v, lw=1.4, color=ACCENT)
-    ax_rsi.fill_between(idx, rsi_v, 70, where=(rsi_v >= 70), alpha=0.18, color=RED)
-    ax_rsi.fill_between(idx, rsi_v, 30, where=(rsi_v <= 30), alpha=0.18, color=GREEN)
-    ax_rsi.fill_between(idx, rsi_v, 50, where=((rsi_v > 50) & (rsi_v < 70)), alpha=0.07, color=GREEN)
-    ax_rsi.fill_between(idx, rsi_v, 50, where=((rsi_v < 50) & (rsi_v > 30)), alpha=0.07, color=RED)
-    for lvl, lbl, c in [(70, 'OB', RED), (50, '50', MUTED), (30, 'OS', GREEN)]:
-        ax_rsi.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
-        ax_rsi.text(len(idx), lvl, f' {lbl}', color=c, fontsize=6.5, va='center')
+    # ── RSI ──────────────────────────────────────────────────────────────────
+    _ax_style(ax_rsi, 'RSI-14  /  RSI-7', 'RSI')
+    r14 = tail['RSI_14'].values
+    r7  = tail['RSI_7'].values
+    ax_rsi.plot(idx, r14, lw=1.3, color=ACID,  label='RSI-14', zorder=4)
+    ax_rsi.plot(idx, r7,  lw=1.0, color=ACID3, label='RSI-7',  zorder=3, alpha=0.7)
+    ax_rsi.fill_between(idx, r14, 70, where=(r14 >= 70), alpha=0.18, color=RED)
+    ax_rsi.fill_between(idx, r14, 30, where=(r14 <= 30), alpha=0.18, color=GREEN)
+    for lvl, c, lbl in [(70, RED, 'OB'), (50, MUTED, '50'), (30, GREEN, 'OS')]:
+        ax_rsi.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
+        ax_rsi.text(len(idx), lvl, f' {lbl}', color=c, fontsize=6, va='center')
     ax_rsi.set_ylim(0, 100)
+    ax_rsi.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
 
-    # ── PANEL 3: MACD ─────────────────────────────────────────────────────────
-    _set_ax_style(ax_macd, 'MACD (12 / 26 / 9)')
+    # ── MACD ─────────────────────────────────────────────────────────────────
+    _ax_style(ax_macd, 'MACD  ·  Fast (5/13)  +  Standard (12/26)')
     macd_v  = tail['MACD'].values
     sig_v   = tail['MACD_Signal'].values
     hist_v  = macd_v - sig_v
-    hcolors = [GREEN if v >= 0 else RED for v in hist_v]
-    ax_macd.bar(idx, hist_v, color=hcolors, alpha=0.45, width=0.75, label='Histogram')
-    ax_macd.plot(idx, macd_v, lw=1.3, color=ACCENT, label='MACD')
-    ax_macd.plot(idx, sig_v,  lw=1.1, color=AMBER,  label='Signal', ls='--')
-    ax_macd.axhline(0, color=MUTED, lw=0.7)
-    ax_macd.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=3)
-
-    # ── PANEL 4: Stochastic ───────────────────────────────────────────────────
-    _set_ax_style(ax_stoch, 'Stochastic (14,3)', '%')
-    stk_v = tail['Stoch_K'].values
-    std_v = tail['Stoch_D'].values
-    ax_stoch.plot(idx, stk_v, lw=1.3, color=ACCENT, label='%K')
-    ax_stoch.plot(idx, std_v, lw=1.0, color=AMBER,  label='%D', ls='--')
-    ax_stoch.fill_between(idx, stk_v, 80, where=(stk_v >= 80), alpha=0.12, color=RED)
-    ax_stoch.fill_between(idx, stk_v, 20, where=(stk_v <= 20), alpha=0.12, color=GREEN)
+    hcol    = [GREEN if v >= 0 else RED for v in hist_v]
+    ax_macd.bar(idx, hist_v, color=hcol, alpha=0.45, width=0.7, label='Hist')
+    ax_macd.plot(idx, macd_v, lw=1.2, color=ACID,  label='MACD')
+    ax_macd.plot(idx, sig_v,  lw=1.0, color=WARN,  label='Signal', ls='--', alpha=0.8)
+    ax_macd.plot(idx, tail['MACD_Fast'].values, lw=0.8, color=ACID3,
+                 label='Fast', ls=':',  alpha=0.7)
+    ax_macd.axhline(0, color=MUTED, lw=0.6)
+    ax_macd.legend(fontsize=6, framealpha=0.1, labelcolor=SUBTEXT, ncol=4)
+
+    # ── STOCHASTIC ────────────────────────────────────────────────────────────
+    _ax_style(ax_stoch, 'Stochastic (14,3)  /  (5,3)', '%')
+    sk = tail['Stoch_K'].values
+    sd = tail['Stoch_D'].values
+    ax_stoch.plot(idx, sk, lw=1.2, color=ACID,  label='%K-14')
+    ax_stoch.plot(idx, sd, lw=1.0, color=WARN,  label='%D-14', ls='--', alpha=0.8)
+    ax_stoch.plot(idx, tail['Stoch_K_5'].values, lw=0.7, color=ACID3,
+                  label='%K-5', ls=':', alpha=0.7)
+    ax_stoch.fill_between(idx, sk, 80, where=(sk >= 80), alpha=0.12, color=RED)
+    ax_stoch.fill_between(idx, sk, 20, where=(sk <= 20), alpha=0.12, color=GREEN)
     for lvl, c in [(80, RED), (20, GREEN)]:
-        ax_stoch.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
+        ax_stoch.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
     ax_stoch.set_ylim(-5, 105)
-    ax_stoch.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
-
-    # ── PANEL 5: CCI ──────────────────────────────────────────────────────────
-    _set_ax_style(ax_cci, 'CCI (20)')
-    cci_v = tail['CCI'].values
-    ax_cci.plot(idx, cci_v, lw=1.3, color=PURPLE)
-    ax_cci.fill_between(idx, cci_v, 100,  where=(cci_v >= 100),  alpha=0.12, color=RED)
-    ax_cci.fill_between(idx, cci_v, -100, where=(cci_v <= -100), alpha=0.12, color=GREEN)
+    ax_stoch.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=3)
+
+    # ── CCI ───────────────────────────────────────────────────────────────────
+    _ax_style(ax_cci, 'CCI-20  /  CCI-10')
+    cci20 = tail['CCI'].values
+    cci10 = tail['CCI_10'].values
+    ax_cci.plot(idx, cci20, lw=1.2, color=ACID3,  label='CCI-20')
+    ax_cci.plot(idx, cci10, lw=0.8, color=ACID2,  label='CCI-10', alpha=0.7, ls='--')
+    ax_cci.fill_between(idx, cci20,  100, where=(cci20 >=  100), alpha=0.12, color=RED)
+    ax_cci.fill_between(idx, cci20, -100, where=(cci20 <= -100), alpha=0.12, color=GREEN)
     for lvl, c in [(100, RED), (0, MUTED), (-100, GREEN)]:
-        ax_cci.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
-
-    # ── PANEL 6: Model karşılaştırması ────────────────────────────────────────
-    _set_ax_style(ax_models, '5 Model Tahmini  vs  Giriş Fiyatı  ·  (ATR TP/SL dahil)', 'Fiyat')
-    names  = list(next_preds.keys())
-    values = [next_preds[n] for n in names]
-    maes   = [float(np.mean(np.abs(test_preds[n] - y_test))) for n in names]
-    x_pos  = np.arange(len(names))
-
-    bcolors = [GREEN if v > cp else RED for v in values]
-    bars = ax_models.bar(x_pos, values, color=bcolors, alpha=0.70,
-                         width=0.55, zorder=3, edgecolor=BORDER, linewidth=0.5)
-
-    ax_models.axhline(y=cp,           color=TEXT,  lw=1.4, ls='--', alpha=0.7,
-                      label=f'Giriş {cp:.5f}', zorder=4)
-    ax_models.axhline(y=ensemble_pred, color=ACCENT2, lw=1.6, ls='-', alpha=0.9,
-                      label=f'Ensemble {ensemble_pred:.5f}', zorder=4)
-    ax_models.axhline(y=tp_sl['tp'],  color=GREEN, lw=1.0, ls=':', alpha=0.7,
-                      label=f"TP {tp_sl['tp']:.5f}", zorder=3)
-    ax_models.axhline(y=tp_sl['sl'],  color=RED,   lw=1.0, ls=':', alpha=0.7,
-                      label=f"SL {tp_sl['sl']:.5f}", zorder=3)
-
-    for bar, val, mae in zip(bars, values, maes):
-        pct   = (val - cp) / cp * 100
-        sign  = '+' if pct >= 0 else ''
-        label = f"{sign}{pct:.3f}%\nMAE {mae:.5f}"
-        y_off = 0.00003 if val >= cp else -0.00006
-        va    = 'bottom' if val >= cp else 'top'
-        ax_models.text(bar.get_x() + bar.get_width() / 2,
-                       val + y_off, label,
-                       ha='center', va=va, fontsize=7, color=TEXT, fontweight='bold')
-
-    ax_models.set_xticks(x_pos)
-    ax_models.set_xticklabels(names, fontsize=8.5, color=TEXT)
-    ax_models.legend(fontsize=7.5, framealpha=0.15, labelcolor=SUBTEXT, ncol=4)
-    ax_models.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
-
-    # ── Ana başlık ────────────────────────────────────────────────────────────
-    direction_label = f"{'▲ LONG' if tp_sl['direction'] == 'LONG' else '▼ SHORT'}  ·  " \
-                      f"TP +{tp_sl['tp_pips']:.0f}p  ·  SL -{tp_sl['sl_pips']:.0f}p  ·  " \
-                      f"R:R 1:{tp_sl['rr']}"
-    dir_color = GREEN if tp_sl['direction'] == 'LONG' else RED
-
-    fig.text(0.06, 0.97, "EUR/USD  ·  ENSEMBLE FORECAST ENGINE",
-             fontsize=13, color=TEXT, fontweight='bold', va='top')
-    fig.text(0.06, 0.955, direction_label,
-             fontsize=9, color=dir_color, va='top')
-    fig.text(0.97, 0.97, datetime.now().strftime('%d %b %Y  %H:%M'),
-             fontsize=8, color=SUBTEXT, va='top', ha='right')
+        ax_cci.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
+    ax_cci.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
+
+    # ── BACKTEST ACCURACY ─────────────────────────────────────────────────────
+    _ax_style(ax_back, f'Ridge Backtest  ·  15-Day Window  ·  α={best_alpha:.4f}  ·  MAE={mae:.6f}', 'Price')
+    bidx = np.arange(len(y_test_abs))
+    ax_back.plot(bidx, y_test_abs,  lw=1.5, color=TEXT,   label='Actual',     zorder=5)
+    ax_back.plot(bidx, test_pred_abs, lw=1.5, color=ACID, label='Ridge Pred', zorder=5, ls='--')
+    ax_back.fill_between(bidx, y_test_abs, test_pred_abs, alpha=0.12, color=ACID2)
+    for i in range(len(bidx)):
+        err = abs(test_pred_abs[i] - y_test_abs[i])
+        ax_back.plot([i, i], [y_test_abs[i], test_pred_abs[i]],
+                     color=ACID2, lw=0.8, alpha=0.5, zorder=3)
+    ax_back.legend(fontsize=7.5, framealpha=0.12, labelcolor=SUBTEXT, ncol=2)
+    ax_back.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
+
+    # ── Header ────────────────────────────────────────────────────────────────
+    dir_label = (f"{'▲ LONG' if tp_sl['direction']=='LONG' else '▼ SHORT'}"
+                 f"  ·  TP +{tp_sl['tp_pips']:.0f}p  ·  SL -{tp_sl['sl_pips']:.0f}p"
+                 f"  ·  R:R 1:{tp_sl['rr']:.1f}"
+                 f"  ·  +{horizon}D forecast")
+    dir_color = GREEN if tp_sl['direction'] == 'LONG' else WARM
+
+    fig.text(0.055, 0.97,
+             "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,
+             fontsize=8.5, color=dir_color, va='top', fontfamily='monospace')
+    fig.text(0.97, 0.97,
+             datetime.now().strftime('%d %b %Y  %H:%M'),
+             fontsize=8, color=SUBTEXT, va='top', ha='right',
+             fontfamily='monospace')
+
+    # Acid-green scan-line signature (subtle)
+    for frac in np.linspace(0.04, 0.93, 28):
+        fig.add_artist(plt.Line2D(
+            [0, 1], [frac, frac], transform=fig.transFigure,
+            color=ACID, alpha=0.007, linewidth=0.4, zorder=0))
 
     return fig
 
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  ANA TAHMİN FONKSİYONU
+#  MAIN PREDICT FUNCTION
 # ══════════════════════════════════════════════════════════════════════════════
 
-def predict_eurusd():
+def predict_eurusd(horizon: int = 1):
     try:
-        # 1. Veri
+        # 1. Data
         data = get_forex_data()
         if data is None:
             return "❌ Veri indirilemedi. İnternet bağlantınızı kontrol edin.", None
 
-        # 2. Feature mühendisliği
+        # 2. Feature engineering
         df = create_features(data)
-        if len(df) < 20:
-            return "❌ Yeterli veri yok (min 20 satır gerekli).", None
+        if len(df) < 40:
+            return "❌ Yetersiz veri (min 40 satır gerekli).", None
 
-        # 3. Eğitim & backtest
-        trained, scaler, test_preds, y_test, avail = train_and_evaluate(df)
+        # 3. Train Ridge + backtest
+        pipe, test_pred_abs, y_test_abs, avail, best_alpha, mae = train_ridge(df, horizon)
 
-        # 4. Tahmin
-        next_preds, ensemble = predict_next(trained, scaler, df, avail)
+        # 4. Predict next
+        pred_price = predict_next_ridge(pipe, df, avail, horizon)
 
-        # 5. TP / SL
+        # 5. TP/SL
         cp  = float(df['Close'].iloc[-1])
         atr = float(df['ATR'].iloc[-1])
-        tp_sl = compute_tp_sl(
-            current_price      = cp,
-            ensemble_pred      = ensemble,
-            atr                = atr,
-            atr_multiplier_sl  = 1.5,
-            rr_ratio           = 2.0,
-        )
-
-        # 6. Sinyal gücü
-        sig = compute_signal_score(df, tp_sl['direction'])
-
-        # 7. Backtest metrikleri
-        ens_test  = np.mean([test_preds[n] for n in test_preds], axis=0)
-        ens_mae   = float(np.mean(np.abs(ens_test - y_test)))
-        ens_rmse  = float(np.sqrt(np.mean((ens_test - y_test) ** 2)))
-        hit_arr   = np.sign(ens_test[1:] - ens_test[:-1]) == np.sign(np.diff(y_test))
-        hit_rate  = float(np.mean(hit_arr)) * 100
-
-        # 8. Teknik durum
-        rsi_val    = float(df['RSI'].iloc[-1])
-        macd_val   = float(df['MACD'].iloc[-1])
-        mhist_val  = float(df['MACD_Hist'].iloc[-1])
-        stk_val    = float(df['Stoch_K'].iloc[-1])
-        std_val    = float(df['Stoch_D'].iloc[-1])
-        cci_val    = float(df['CCI'].iloc[-1])
-        wr_val     = float(df['WilliamsR'].iloc[-1])
-        bb_pct_val = float(df['BB_pct'].iloc[-1])
-        vol20_val  = float(df['Volatility_20'].iloc[-1]) * 100
-        atr_pct    = float(df['ATR_Pct'].iloc[-1]) * 100
-
-        rsi_lbl  = "Aşırı Alım ⚠" if rsi_val > 70 else ("Aşırı Satım ⚠" if rsi_val < 30 else "Nötr  ✓")
-        macd_lbl = "Boğa ▲" if macd_val > 0 else "Ayı  ▼"
-        stk_lbl  = "%K > %D  ▲" if stk_val > std_val else "%K < %D  ▼"
-        ens_chg  = (ensemble - cp) / cp * 100
-
-        # ── Rapor metni ───────────────────────────────────────────────────────
-        W = 52   # satır genişliği
-        sep  = "━" * W
-        sep2 = "─" * W
+        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'])
+
+        # 7. Backtest metrics
+        rmse = float(np.sqrt(np.mean((test_pred_abs - y_test_abs) ** 2)))
+        hit  = float(np.mean(
+            np.sign(np.diff(test_pred_abs)) == np.sign(np.diff(y_test_abs))
+        )) * 100
+
+        # 8. Indicators
+        rsi  = float(df['RSI_14'].iloc[-1])
+        macd = float(df['MACD'].iloc[-1])
+        mh   = float(df['MACD_Hist'].iloc[-1])
+        stk  = float(df['Stoch_K'].iloc[-1])
+        std  = float(df['Stoch_D'].iloc[-1])
+        cci  = float(df['CCI'].iloc[-1])
+        wr   = float(df['WilliamsR'].iloc[-1])
+        bb   = float(df['BB_pct_20'].iloc[-1])
+        vr   = float(df['Vol_20'].iloc[-1]) * 100
+        roc5 = float(df['ROC_5'].iloc[-1]) * 100
+        chg  = (pred_price - cp) / cp * 100
+
+        rsi_lbl  = "Aşırı Alım ⚠️" if rsi > 70 else ("Aşırı Satım ⚠️" if rsi < 30 else "Nötr  ✓")
+        macd_lbl = "Boğa ▲" if macd > 0 else "Ayı  ▼"
+
+        W   = 54
+        sep = "═" * W
 
         lines = [
             sep,
-            f"  EUR/USD  ·  ENSEMBLE FORECAST ENGINE",
+            f"  EUR/USD  ·  RIDGE FORECAST ENGINE  ·  ULTRA-PREMIUM",
             f"  {datetime.now().strftime('%d %b %Y  %H:%M:%S')}",
             sep,
             "",
-            f"  {'MEVCUT FİYAT':<22}:  {cp:.5f}",
-            f"  {'ENSEMBLE TAHMİN':<22}:  {ensemble:.5f}  ({ens_chg:+.3f}%)",
-            f"  {'YÖN':<22}:  {tp_sl['direction']}",
+            f"  {'MEVCUT FİYAT':<24}:  {cp:.5f}",
+            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"  {'─── RİSK YÖNETİMİ (ATR × 1.5 / R:R 1:2)':<{W-2}}",
-            f"  {'GİRİŞ':<22}:  {tp_sl['entry']:.5f}",
-            f"  {'TAKE PROFIT (TP)':<22}:  {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f} pip)",
-            f"  {'STOP LOSS (SL)':<22}:  {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f} pip)",
-            f"  {'R:R ORANI':<22}:  1 : {tp_sl['rr']:.1f}",
-            f"  {'RISK (%)':<22}:  {tp_sl['risk_pct']:.3f}%",
-            f"  {'ATR (14)':<22}:  {atr:.5f}  ({atr_pct:.3f}%)",
+            f"  {'─── RİSK YÖNETİMİ (ATR × 1.5  |  R:R 1:2)':<{W-2}}",
+            f"  {'GİRİŞ':<24}:  {tp_sl['entry']:.5f}",
+            f"  {'TAKE PROFIT':<24}:  {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f} pip)",
+            f"  {'STOP LOSS':<24}:  {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f} pip)",
+            f"  {'R:R':<24}:  1 : {tp_sl['rr']:.1f}",
+            f"  {'RİSK %':<24}:  {tp_sl['risk_pct']:.3f}%",
+            f"  {'ATR-14':<24}:  {atr:.5f}",
             "",
             f"  {'─── SİNYAL GÜCÜ':<{W-2}}",
-            f"  {'SKOR':<22}:  {sig['score']:.0f} / 100  →  {sig['label']}",
+            f"  {'SKOR':<24}:  {sig['score']:.0f} / 100  →  {sig['label']}",
         ]
-
-        for ind, detail in sig['details'].items():
-            lines.append(f"    {ind:<20}:  {detail}")
+        for k, v in sig['details'].items():
+            lines.append(f"    {k:<22}:  {v}")
 
         lines += [
             "",
             f"  {'─── TEKNİK GÖSTERGELER':<{W-2}}",
-            f"  {'RSI (14)':<22}:  {rsi_val:.2f}  →  {rsi_lbl}",
-            f"  {'MACD':<22}:  {macd_val:.5f}  →  {macd_lbl}",
-            f"  {'MACD Histogram':<22}:  {mhist_val:.5f}",
-            f"  {'Stochastic K/D':<22}:  {stk_val:.1f} / {std_val:.1f}  →  {stk_lbl}",
-            f"  {'CCI (20)':<22}:  {cci_val:.1f}",
-            f"  {'Williams %R':<22}:  {wr_val:.1f}",
-            f"  {'BB Pozisyonu (%)':<22}:  {bb_pct_val:.3f}",
-            f"  {'Volatilite (20g σ)':<22}:  {vol20_val:.4f}%",
+            f"  {'RSI-14':<24}:  {rsi:.2f}  →  {rsi_lbl}",
+            f"  {'RSI-7':<24}:  {float(df['RSI_7'].iloc[-1]):.2f}",
+            f"  {'MACD':<24}:  {macd:.5f}  →  {macd_lbl}",
+            f"  {'MACD Histogram':<24}:  {mh:.5f}",
+            f"  {'Stoch K/D':<24}:  {stk:.1f} / {std:.1f}",
+            f"  {'CCI-20':<24}:  {cci:.1f}",
+            f"  {'Williams %R':<24}:  {wr:.1f}",
+            f"  {'BB% (20)':<24}:  {bb:.3f}",
+            f"  {'ROC-5 (%)':<24}:  {roc5:.4f}%",
+            f"  {'Volatilite σ20':<24}:  {vr:.4f}%",
             "",
-            f"  {'─── MODEL TAHMİNLERİ':<{W-2}}",
-        ]
-
-        for name, val in next_preds.items():
-            chg  = (val - cp) / cp * 100
-            mae  = float(np.mean(np.abs(test_preds[name] - y_test)))
-            rmse = float(np.sqrt(np.mean((test_preds[name] - y_test) ** 2)))
-            ar   = "▲" if chg > 0 else "▼"
-            lines.append(
-                f"  {name:<22}:  {val:.5f}  ({chg:+.3f}%)  {ar}"
-                f"  MAE={mae:.5f}  RMSE={rmse:.5f}"
-            )
-
-        lines += [
-            "",
-            f"  {'─── BACKTEST (Son 10 Gün)':<{W-2}}",
-            f"  {'Ensemble MAE':<22}:  {ens_mae:.6f}",
-            f"  {'Ensemble RMSE':<22}:  {ens_rmse:.6f}",
-            f"  {'Yön Doğruluğu':<22}:  {hit_rate:.1f}%",
+            f"  {'─── BACKTEST (Son 15 Gün)':<{W-2}}",
+            f"  {'MAE':<24}:  {mae:.7f}",
+            f"  {'RMSE':<24}:  {rmse:.7f}",
+            f"  {'Yön Doğruluğu':<24}:  {hit:.1f}%",
+            f"  {'Feature Sayısı':<24}:  {len(avail)}",
             "",
             sep,
-            f"  ⚠  Yalnızca eğitim amaçlıdır. Finansal tavsiye değildir.",
+            "  ⚠  Yalnızca eğitim amaçlıdır. Finansal tavsiye değildir.",
             sep,
         ]
 
-        output_text = "\n".join(lines)
+        text = "\n".join(lines)
 
-        # 9. Grafik
-        fig = build_figure(df, next_preds, ensemble, test_preds, y_test, tp_sl)
+        # 9. Figure
+        fig = build_figure(
+            df, pred_price, horizon, tp_sl,
+            test_pred_abs, y_test_abs, best_alpha, mae,
+        )
 
-        return output_text, fig
+        return text, fig
 
     except Exception:
         return f"❌ Hata:\n{traceback.format_exc()}", None
 
 
+def run_1d(): return predict_eurusd(horizon=1)
+def run_2d(): return predict_eurusd(horizon=2)
+
+
 # ══════════════════════════════════════════════════════════════════════════════
-#  CSS & HTML
+#  CSS
 # ══════════════════════════════════════════════════════════════════════════════
 
 CSS = """
-* { box-sizing: border-box; }
+*, *::before, *::after { box-sizing: border-box; }
+
 body, .gradio-container {
-    background: #0A0E17 !important;
-    font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace !important;
-    color: #F1F5F9 !important;
+    background: #080C12 !important;
+    font-family: 'JetBrains Mono', 'Cascadia Code', 'Fira Code', monospace !important;
+    color: #E8EDF5 !important;
+}
+
+/* Buttons */
+.btn-row button {
+    background: transparent !important;
+    border: 1px solid #1A2233 !important;
+    color: #6B7E99 !important;
+    font-family: 'JetBrains Mono', monospace !important;
+    font-size: 0.85rem !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.08em !important;
+    padding: 13px 28px !important;
+    border-radius: 4px !important;
+    transition: all 0.18s ease !important;
+}
+
+.btn-1d button {
+    background: linear-gradient(135deg, #003D28 0%, #00261A 100%) !important;
+    border: 1px solid #00FFB2 !important;
+    color: #00FFB2 !important;
+    box-shadow: 0 0 18px rgba(0,255,178,0.12) !important;
+}
+.btn-1d button:hover {
+    box-shadow: 0 0 30px rgba(0,255,178,0.25) !important;
+    filter: brightness(1.1) !important;
 }
-button.lg.primary {
-    background: linear-gradient(135deg, #1D4ED8 0%, #4F46E5 100%) !important;
-    border: none !important;
-    color: #fff !important;
-    font-weight: 700 !important;
-    letter-spacing: .06em !important;
-    padding: 14px 36px !important;
-    border-radius: 6px !important;
-    font-size: 1rem !important;
-    transition: filter .2s !important;
+
+.btn-2d button {
+    background: linear-gradient(135deg, #1A1040 0%, #100A30 100%) !important;
+    border: 1px solid #7B61FF !important;
+    color: #7B61FF !important;
+    box-shadow: 0 0 18px rgba(123,97,255,0.12) !important;
+}
+.btn-2d button:hover {
+    box-shadow: 0 0 30px rgba(123,97,255,0.25) !important;
+    filter: brightness(1.1) !important;
 }
-button.lg.primary:hover { filter: brightness(1.15) !important; }
+
+/* Textbox */
 .gr-textbox textarea, textarea {
-    background: #0F1623 !important;
-    color: #94A3B8 !important;
-    border: 1px solid #1E293B !important;
+    background: #0C1119 !important;
+    color: #00FFB2 !important;
+    border: 1px solid #1A2233 !important;
     font-family: 'JetBrains Mono', monospace !important;
-    font-size: 12px !important;
-    line-height: 1.8 !important;
-    border-radius: 6px !important;
+    font-size: 11.5px !important;
+    line-height: 1.85 !important;
+    border-radius: 4px !important;
+    caret-color: #00FFB2 !important;
 }
-label span { color: #64748B !important; font-size: .78rem !important; }
-.gr-panel, .gr-box { background: #111827 !important; border: 1px solid #1E293B !important; }
+
+label span { color: #3A4A5E !important; font-size: .75rem !important; }
+.gr-panel, .gr-box { background: #0C1119 !important; border: 1px solid #1A2233 !important; }
 footer { display: none !important; }
+
+/* Scan-line overlay on header */
+.header-wrap::after {
+    content: '';
+    position: absolute; inset: 0;
+    background: repeating-linear-gradient(
+        0deg,
+        transparent,
+        transparent 3px,
+        rgba(0,255,178,0.012) 3px,
+        rgba(0,255,178,0.012) 4px
+    );
+    pointer-events: none;
+    border-radius: 8px;
+}
+.header-wrap { position: relative; }
 """
 
 HEADER = """
-<div style="
-    background: linear-gradient(160deg,#0A0E17 0%,#0F1623 60%,#111827 100%);
-    border: 1px solid #1E293B;
-    border-radius: 10px;
-    padding: 28px 32px 22px;
-    margin-bottom: 12px;
+<div class="header-wrap" style="
+    background: linear-gradient(155deg, #080C12 0%, #0C1119 50%, #080C12 100%);
+    border: 1px solid #1A2233;
+    border-top: 2px solid #00FFB2;
+    border-radius: 8px;
+    padding: 26px 32px 20px;
+    margin-bottom: 14px;
 ">
-  <div style="display:flex;align-items:center;gap:16px;margin-bottom:12px;">
-    <span style="font-size:2.4rem;line-height:1;">💹</span>
+  <div style="display:flex;align-items:flex-start;gap:18px;">
+    <div style="flex-shrink:0;margin-top:3px;">
+      <svg width="40" height="40" viewBox="0 0 40 40" fill="none">
+        <rect width="40" height="40" rx="6" fill="#003D28"/>
+        <polyline points="6,28 13,18 20,22 27,12 34,16"
+                  stroke="#00FFB2" stroke-width="2.5" fill="none"
+                  stroke-linecap="round" stroke-linejoin="round"/>
+        <circle cx="27" cy="12" r="2.5" fill="#00FFB2"/>
+      </svg>
+    </div>
     <div>
-      <h1 style="margin:0;font-size:1.6rem;font-weight:900;color:#F1F5F9;letter-spacing:.05em;">
-        EUR/USD &nbsp;·&nbsp; ENSEMBLE FORECAST ENGINE
+      <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; 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:5px 0 0;color:#64748B;font-size:.8rem;font-family:monospace;">
-        Random Forest &nbsp;·&nbsp; Gradient Boosting &nbsp;·&nbsp;
-        AdaBoost &nbsp;·&nbsp; Ridge &nbsp;·&nbsp; SVR
+      <p style="margin:0;color:#3A4A5E;font-size:.75rem;font-family:monospace;
+                letter-spacing:.04em;">
+        STACKED RIDGE · POLYNOMIAL INTERACTIONS · RIDGECV ALPHA · 75+ FEATURES · ATR TP/SL
       </p>
     </div>
   </div>
-  <div style="display:flex;gap:10px;flex-wrap:wrap;margin-top:4px;">
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📡 Yahoo Finance 150g</span>
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📐 42 Feature</span>
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">🧪 10-Gün Backtest</span>
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">🎯 ATR TP/SL</span>
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📊 5 Teknik Osilatör</span>
-    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">⚡ Tek Tıkla Güncelle</span>
+  <div style="display:flex;gap:8px;flex-wrap:wrap;margin-top:16px;">
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      📡 Yahoo Finance 200g</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      🧬 75+ Features</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      🔬 Poly-2 Interactions</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      ⚡ RidgeCV Auto-α</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      🎯 ATR TP/SL</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      📅 1D / 2D Horizon</span>
+    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
+                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
+      🧪 15-Day Backtest</span>
   </div>
 </div>
 """
 
 # ══════════════════════════════════════════════════════════════════════════════
-#  GRADIO ARAYÜZÜ
+#  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():
-        predict_btn = gr.Button("⟳  TAHMİN YAP / YENİLE", variant="primary", scale=1)
+    with gr.Row(elem_classes="btn-row"):
+        with gr.Column(scale=1, elem_classes="btn-1d"):
+            btn_1d = gr.Button("⟳  +1 GÜN TAHMİN", variant="primary")
+        with gr.Column(scale=1, elem_classes="btn-2d"):
+            btn_2d = gr.Button("⟳  +2 GÜN TAHMİN", variant="primary")
+        with gr.Column(scale=3):
+            pass   # spacer
 
     with gr.Row():
-        with gr.Column(scale=1, min_width=380):
-            output_text = gr.Textbox(
-                label="RAPOR",
-                lines=38,
-                interactive=False,
-            )
+        with gr.Column(scale=1, min_width=400):
+            out_text = gr.Textbox(label="RAPOR", lines=42, interactive=False)
         with gr.Column(scale=2):
-            output_plot = gr.Plot(label="GRAFİKLER")
+            out_plot = gr.Plot(label="GRAFİKLER")
 
-    predict_btn.click(
-        fn=predict_eurusd,
-        inputs=[],
-        outputs=[output_text, output_plot],
-    )
+    btn_1d.click(fn=run_1d, inputs=[], outputs=[out_text, out_plot])
+    btn_2d.click(fn=run_2d, inputs=[], outputs=[out_text, out_plot])
 
 if __name__ == "__main__":
     app.launch()