Update app.py

app.py

@@ -5,55 +5,65 @@ warnings.filterwarnings("ignore")
 import time
 import numpy as np
 import pandas as pd
-import gradio as gr
 import ccxt
+import gradio as gr
 import optuna
 
-from sklearn.ensemble import (
-    ExtraTreesClassifier,
-    HistGradientBoostingClassifier
-)
-from sklearn.linear_model import LogisticRegression
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
-from sklearn.model_selection import TimeSeriesSplit
+from sklearn.linear_model import LogisticRegression
 from sklearn.metrics import (
     accuracy_score,
     balanced_accuracy_score,
-    roc_auc_score
+    brier_score_loss
 )
+from sklearn.model_selection import TimeSeriesSplit
 
 
-# =========================================================
+# ============================================================
 # CONFIG
-# =========================================================
+# ============================================================
 
 SYMBOL = "BTC/USDT:USDT"
+TIMEFRAME = "1h"
+TIMEFRAME_MS = 60 * 60 * 1000
+
+FEATURE_COLUMNS = [
+    "ret_1", "ret_2", "ret_3", "ret_6",
+    "ret_12", "ret_24", "ret_48", "ret_96",
+
+    "rv_12", "rv_24", "rv_48", "rv_96",
+    "vol_ratio",
+
+    "zscore_24", "zscore_48",
+
+    "range_pct", "body_pct",
+    "upper_wick", "lower_wick",
+    "close_position",
+
+    "parkinson_24",
 
-FEATURES = [
-    "rsi",
-    "macd_pct",
-    "macd_signal_pct",
-    "macd_hist_pct",
-    "supertrend_direction",
-    "supertrend_distance",
-    "vwap_distance",
-    "atr_pct",
-    "return_1",
-    "return_3",
-    "return_6",
-    "volatility_14",
-    "volume_ratio",
-    "body_pct",
-    "high_low_pct"
+    "skew_48", "kurt_48",
+    "autocorr_48",
+
+    "hurst_64",
+    "entropy_48",
+
+    "kalman_gap",
+    "kalman_trend_6",
+    "kalman_innovation",
+
+    "volume_change",
+    "volume_zscore",
+    "volume_price_corr"
 ]
 
 
-# =========================================================
-# OKX DATA FETCH
-# =========================================================
+# ============================================================
+# OKX CONNECTION
+# ============================================================
 
-def fetch_data(timeframe="1h", candles=2000):
+def create_exchange():
 
     exchange = ccxt.okx({
         "enableRateLimit": True,
@@ -63,67 +73,63 @@ def fetch_data(timeframe="1h", candles=2000):
         }
     })
 
+    return exchange
+
+
+def fetch_data(candle_count):
+
+    exchange = create_exchange()
+
     exchange.load_markets()
 
     if SYMBOL not in exchange.markets:
         raise ValueError(
-            f"OKX perpetual sembolü bulunamadı: {SYMBOL}"
+            f"OKX piyasasında {SYMBOL} bulunamadı."
         )
 
-    timeframe_ms = exchange.parse_timeframe(timeframe) * 1000
+    now = exchange.milliseconds()
 
-    since = (
-        exchange.milliseconds()
-        - (candles + 10) * timeframe_ms
-    )
+    since = now - (candle_count + 20) * TIMEFRAME_MS
 
-    all_rows = {}
-    requests = 0
-    max_requests = max(20, candles // 80 + 10)
+    all_candles = []
+    cursor = since
 
-    while len(all_rows) < candles and requests < max_requests:
+    max_requests = int(candle_count / 100) + 15
 
-        requests += 1
+    for _ in range(max_requests):
 
         batch = exchange.fetch_ohlcv(
             SYMBOL,
-            timeframe=timeframe,
-            since=since,
+            timeframe=TIMEFRAME,
+            since=cursor,
             limit=100
         )
 
         if not batch:
             break
 
-        old_count = len(all_rows)
-
-        for row in batch:
-            all_rows[int(row[0])] = row
+        all_candles.extend(batch)
 
-        new_count = len(all_rows)
+        last_timestamp = batch[-1][0]
 
-        last_timestamp = max(int(row[0]) for row in batch)
-
-        new_since = last_timestamp + timeframe_ms
-
-        if new_since <= since:
+        if last_timestamp <= cursor:
             break
 
-        since = new_since
+        cursor = last_timestamp + TIMEFRAME_MS
 
-        if new_count == old_count:
+        if len(all_candles) >= candle_count + 100:
             break
 
-        if len(batch) < 100:
+        if last_timestamp >= now - TIMEFRAME_MS:
             break
 
         time.sleep(exchange.rateLimit / 1000)
 
-    if not all_rows:
+    if not all_candles:
         raise ValueError("OKX veri döndürmedi.")
 
     df = pd.DataFrame(
-        list(all_rows.values()),
+        all_candles,
         columns=[
             "timestamp",
             "open",
@@ -134,643 +140,853 @@ def fetch_data(timeframe="1h", candles=2000):
         ]
     )
 
+    df = df.drop_duplicates(
+        subset=["timestamp"]
+    )
+
     df = df.sort_values("timestamp")
-    df = df.drop_duplicates("timestamp")
 
-    df["timestamp"] = pd.to_datetime(
-        df["timestamp"],
-        unit="ms",
-        utc=True
-    )
+    # Henüz tamamlanmamış mumları çıkar.
+    now = exchange.milliseconds()
+
+    df = df[
+        df["timestamp"] + TIMEFRAME_MS <= now
+    ]
 
-    df = df.set_index("timestamp")
+    df = df.tail(candle_count).reset_index(drop=True)
 
-    for col in [
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume"
-    ]:
+    for col in ["open", "high", "low", "close", "volume"]:
         df[col] = pd.to_numeric(
             df[col],
             errors="coerce"
         )
 
-    df = df.dropna()
+    df = df.replace(
+        [np.inf, -np.inf],
+        np.nan
+    )
 
-    # Henüz tamamlanmamış mum
-    if len(df) > 1:
-        df = df.iloc[:-1]
+    df = df.dropna().reset_index(drop=True)
 
-    df = df.tail(candles)
+    df = df[
+        (df["close"] > 0) &
+        (df["high"] >= df["low"]) &
+        (df["volume"] >= 0)
+    ].reset_index(drop=True)
 
-    if len(df) < 200:
+    if len(df) < 500:
         raise ValueError(
-            f"OKX yalnızca {len(df)} mum döndürdü. "
-            "Daha yüksek mum sayısı veya farklı timeframe deneyin."
+            f"Yeterli OKX verisi yok. Gelen mum: {len(df)}"
         )
 
     return df
 
 
-# =========================================================
-# INDICATORS
-# =========================================================
+# ============================================================
+# MATHEMATICAL FUNCTIONS
+# ============================================================
 
-def calculate_indicators(df):
+def safe_div(a, b):
 
-    df = df.copy()
+    return a / (b.replace(0, np.nan) if isinstance(b, pd.Series) else b)
 
-    # ATR 10
-    previous_close = df["close"].shift(1)
 
-    tr = pd.concat([
-        df["high"] - df["low"],
-        (df["high"] - previous_close).abs(),
-        (df["low"] - previous_close).abs()
-    ], axis=1).max(axis=1)
+def shannon_entropy(values):
 
-    df["atr"] = tr.ewm(
-        alpha=1 / 10,
-        adjust=False,
-        min_periods=10
-    ).mean()
+    x = np.asarray(values)
 
-    # RSI 14
-    delta = df["close"].diff()
+    signs = np.sign(x)
 
-    gain = delta.clip(lower=0)
-    loss = -delta.clip(upper=0)
+    counts = np.bincount(
+        (signs + 1).astype(int),
+        minlength=3
+    )
 
-    avg_gain = gain.ewm(
-        alpha=1 / 14,
-        adjust=False,
-        min_periods=14
-    ).mean()
+    probabilities = counts / counts.sum()
 
-    avg_loss = loss.ewm(
-        alpha=1 / 14,
-        adjust=False,
-        min_periods=14
-    ).mean()
+    probabilities = probabilities[
+        probabilities > 0
+    ]
 
-    rs = avg_gain / avg_loss.replace(0, np.nan)
+    entropy = -np.sum(
+        probabilities * np.log(probabilities)
+    )
 
-    df["rsi"] = 100 - 100 / (1 + rs)
+    return entropy / np.log(3)
 
-    # MACD 12,26,9
-    ema12 = df["close"].ewm(
-        span=12,
-        adjust=False
-    ).mean()
 
-    ema26 = df["close"].ewm(
-        span=26,
-        adjust=False
-    ).mean()
+def hurst_exponent(values):
 
-    df["macd"] = ema12 - ema26
+    x = np.asarray(values)
 
-    df["macd_signal"] = df["macd"].ewm(
-        span=9,
-        adjust=False
-    ).mean()
+    if len(x) < 32:
+        return np.nan
 
-    df["macd_hist"] = (
-        df["macd"] - df["macd_signal"]
-    )
+    lags = np.array([1, 2, 4, 8])
 
-    # SUPERTREND 10,3
-    hl2 = (df["high"] + df["low"]) / 2
+    tau = []
 
-    basic_upper = hl2 + 3 * df["atr"]
-    basic_lower = hl2 - 3 * df["atr"]
+    for lag in lags:
 
-    final_upper = basic_upper.copy()
-    final_lower = basic_lower.copy()
+        differences = x[lag:] - x[:-lag]
 
-    direction = pd.Series(
-        1.0,
-        index=df.index
-    )
+        value = np.std(differences)
 
-    supertrend = pd.Series(
-        np.nan,
-        index=df.index
-    )
+        if value <= 0:
+            return np.nan
 
-    for i in range(1, len(df)):
+        tau.append(value)
 
-        previous_close_value = df["close"].iloc[i - 1]
+    slope = np.polyfit(
+        np.log(lags),
+        np.log(tau),
+        1
+    )[0]
 
-        if (
-            basic_upper.iloc[i] < final_upper.iloc[i - 1]
-            or previous_close_value > final_upper.iloc[i - 1]
-        ):
-            final_upper.iloc[i] = basic_upper.iloc[i]
-        else:
-            final_upper.iloc[i] = final_upper.iloc[i - 1]
+    return float(np.clip(slope, 0, 1))
 
-        if (
-            basic_lower.iloc[i] > final_lower.iloc[i - 1]
-            or previous_close_value < final_lower.iloc[i - 1]
-        ):
-            final_lower.iloc[i] = basic_lower.iloc[i]
-        else:
-            final_lower.iloc[i] = final_lower.iloc[i - 1]
 
-        current_close = df["close"].iloc[i]
+def kalman_filter(log_prices):
 
-        if direction.iloc[i - 1] == -1:
+    prices = np.asarray(log_prices)
 
-            direction.iloc[i] = (
-                1 if current_close > final_upper.iloc[i]
-                else -1
-            )
+    n = len(prices)
 
-        else:
+    filtered = np.zeros(n)
+    innovations = np.zeros(n)
 
-            direction.iloc[i] = (
-                -1 if current_close < final_lower.iloc[i]
-                else 1
-            )
+    q = 0.000001
+    r = 0.000025
+
+    estimate = prices[0]
+    variance = 0.001
+
+    for i in range(n):
+
+        predicted = estimate
+
+        predicted_variance = variance + q
+
+        innovation = prices[i] - predicted
+
+        total_variance = predicted_variance + r
 
-        supertrend.iloc[i] = (
-            final_lower.iloc[i]
-            if direction.iloc[i] == 1
-            else final_upper.iloc[i]
+        gain = predicted_variance / total_variance
+
+        estimate = predicted + gain * innovation
+
+        variance = (1 - gain) * predicted_variance
+
+        filtered[i] = estimate
+
+        innovations[i] = (
+            innovation / np.sqrt(total_variance)
         )
 
-    df["supertrend"] = supertrend
-    df["supertrend_direction"] = direction
+    return filtered, innovations
 
-    # VWAP - UTC daily reset
-    typical_price = (
-        df["high"] + df["low"] + df["close"]
-    ) / 3
 
-    daily_group = df.index.date
+# ============================================================
+# QUANT FEATURE ENGINEERING
+# NO RSI / MACD / EMA / SUPERTREND / VWAP
+# ============================================================
 
-    cumulative_pv = (
-        (typical_price * df["volume"])
-        .groupby(daily_group)
-        .cumsum()
-    )
+def calculate_quant_features(df):
 
-    cumulative_volume = (
-        df["volume"]
-        .groupby(daily_group)
-        .cumsum()
-    )
+    data = df.copy()
+
+    log_close = np.log(data["close"])
+
+    log_open = np.log(data["open"])
+    log_high = np.log(data["high"])
+    log_low = np.log(data["low"])
+
+    returns = log_close.diff()
+
+    # --------------------------------------------------------
+    # LOG RETURNS
+    # --------------------------------------------------------
+
+    for period in [1, 2, 3, 6, 12, 24, 48, 96]:
+
+        data[f"ret_{period}"] = (
+            log_close - log_close.shift(period)
+        )
+
+    # --------------------------------------------------------
+    # REALIZED VOLATILITY
+    # --------------------------------------------------------
+
+    for window in [12, 24, 48, 96]:
 
-    df["vwap"] = (
-        cumulative_pv /
-        cumulative_volume.replace(0, np.nan)
+        data[f"rv_{window}"] = (
+            returns.rolling(window).std()
+        )
+
+    data["vol_ratio"] = safe_div(
+        data["rv_24"],
+        data["rv_96"]
     )
 
-    # FEATURES
-    df["macd_pct"] = df["macd"] / df["close"] * 100
+    # --------------------------------------------------------
+    # Z-SCORE
+    # --------------------------------------------------------
+
+    for window in [24, 48]:
+
+        mean = log_close.rolling(window).mean()
+
+        std = log_close.rolling(window).std()
+
+        data[f"zscore_{window}"] = safe_div(
+            log_close - mean,
+            std
+        )
+
+    # --------------------------------------------------------
+    # CANDLE DISTRIBUTION MATHEMATICS
+    # --------------------------------------------------------
+
+    data["range_pct"] = log_high - log_low
 
-    df["macd_signal_pct"] = (
-        df["macd_signal"] / df["close"] * 100
+    data["body_pct"] = log_close - log_open
+
+    candle_range = (
+        data["high"] - data["low"]
+    ).replace(0, np.nan)
+
+    data["upper_wick"] = (
+        data["high"] -
+        data[["open", "close"]].max(axis=1)
+    ) / candle_range
+
+    data["lower_wick"] = (
+        data[["open", "close"]].min(axis=1) -
+        data["low"]
+    ) / candle_range
+
+    data["close_position"] = (
+        data["close"] - data["low"]
+    ) / candle_range
+
+    # --------------------------------------------------------
+    # PARKINSON VOLATILITY ESTIMATOR
+    # --------------------------------------------------------
+
+    squared_range = (
+        np.log(data["high"] / data["low"]) ** 2
     )
 
-    df["macd_hist_pct"] = (
-        df["macd_hist"] / df["close"] * 100
+    data["parkinson_24"] = np.sqrt(
+        squared_range.rolling(24).mean()
+        / (4 * np.log(2))
     )
 
-    df["supertrend_distance"] = (
-        (df["close"] - df["supertrend"])
-        / df["close"] * 100
+    # --------------------------------------------------------
+    # DISTRIBUTION STATISTICS
+    # --------------------------------------------------------
+
+    data["skew_48"] = returns.rolling(48).skew()
+
+    data["kurt_48"] = returns.rolling(48).kurt()
+
+    # --------------------------------------------------------
+    # AUTOCORRELATION
+    # --------------------------------------------------------
+
+    data["autocorr_48"] = (
+        returns.rolling(48).corr(returns.shift(1))
     )
 
-    df["vwap_distance"] = (
-        (df["close"] - df["vwap"])
-        / df["close"] * 100
+    # --------------------------------------------------------
+    # HURST EXPONENT
+    # --------------------------------------------------------
+
+    data["hurst_64"] = log_close.rolling(
+        64
+    ).apply(
+        hurst_exponent,
+        raw=True
     )
 
-    df["atr_pct"] = df["atr"] / df["close"] * 100
+    # --------------------------------------------------------
+    # SHANNON ENTROPY
+    # --------------------------------------------------------
 
-    df["return_1"] = df["close"].pct_change(1) * 100
-    df["return_3"] = df["close"].pct_change(3) * 100
-    df["return_6"] = df["close"].pct_change(6) * 100
+    data["entropy_48"] = returns.rolling(
+        48
+    ).apply(
+        shannon_entropy,
+        raw=True
+    )
 
-    df["volatility_14"] = (
-        df["return_1"].rolling(14).std()
+    # --------------------------------------------------------
+    # KALMAN FILTER
+    # --------------------------------------------------------
+
+    filtered, innovations = kalman_filter(
+        log_close.values
     )
 
-    volume_avg = df["volume"].rolling(20).mean()
+    data["kalman_gap"] = (
+        log_close.values - filtered
+    )
 
-    df["volume_ratio"] = (
-        df["volume"] /
-        volume_avg.replace(0, np.nan)
+    data["kalman_trend_6"] = (
+        pd.Series(filtered).diff(6).values
     )
 
-    df["body_pct"] = (
-        (df["close"] - df["open"])
-        / df["open"] * 100
+    data["kalman_innovation"] = innovations
+
+    # --------------------------------------------------------
+    # VOLUME MATHEMATICS
+    # --------------------------------------------------------
+
+    log_volume = np.log1p(data["volume"])
+
+    data["volume_change"] = log_volume.diff()
+
+    volume_mean = log_volume.rolling(48).mean()
+
+    volume_std = log_volume.rolling(48).std()
+
+    data["volume_zscore"] = safe_div(
+        log_volume - volume_mean,
+        volume_std
     )
 
-    df["high_low_pct"] = (
-        (df["high"] - df["low"])
-        / df["close"] * 100
+    data["volume_price_corr"] = (
+        returns.rolling(48).corr(
+            data["volume_change"]
+        )
     )
 
-    return df
+    return data
 
 
-# =========================================================
+# ============================================================
 # DATASET
-# =========================================================
+# ============================================================
 
 def prepare_dataset(raw, horizon):
 
-    data = calculate_indicators(raw)
+    features = calculate_quant_features(raw)
 
-    future_close = data["close"].shift(-horizon)
+    features["raw_i"] = np.arange(len(features))
 
-    data["target"] = (
-        future_close > data["close"]
-    ).astype(int)
+    future_close = features["close"].shift(-horizon)
 
-    # Gelecek hedefi bulunmayan son mumları çıkar.
-    data = data.iloc[:-horizon].copy()
+    features["target"] = np.where(
+        future_close.notna(),
+        (future_close > features["close"]).astype(float),
+        np.nan
+    )
 
-    data = data.replace(
+    features = features.replace(
         [np.inf, -np.inf],
         np.nan
     )
 
-    data = data.dropna(
-        subset=FEATURES + ["target", "atr"]
-    )
+    live_features = features.dropna(
+        subset=FEATURE_COLUMNS
+    ).copy()
+
+    dataset = live_features.dropna(
+        subset=["target"]
+    ).copy()
+
+    dataset = dataset.reset_index(drop=True)
 
-    if len(data) < 150:
+    live_features = live_features.reset_index(drop=True)
+
+    if len(dataset) < 500:
         raise ValueError(
-            f"Temiz veri sayısı {len(data)}. "
-            "En az 150 örnek gerekli. Mum sayısını artırın "
-            "veya daha büyük timeframe deneyin."
+            "Temiz eğitim verisi 500 örneğin altında. "
+            f"Mevcut: {len(dataset)}"
         )
 
-    return data
+    X = dataset[FEATURE_COLUMNS].astype(float)
 
+    y = dataset["target"].astype(int)
 
-# =========================================================
-# MODEL FACTORY
-# =========================================================
+    if y.nunique() < 2:
+        raise ValueError(
+            "Eğitim verisinde iki sınıf da bulunmalı."
+        )
 
-def create_models(params):
+    return X, y, dataset, live_features
 
-    extra = ExtraTreesClassifier(
-        n_estimators=params["extra_trees"],
-        max_depth=params["extra_depth"],
-        min_samples_leaf=params["extra_leaf"],
-        max_features=0.8,
-        class_weight="balanced",
-        random_state=42,
-        n_jobs=-1
-    )
 
-    hist = HistGradientBoostingClassifier(
-        max_iter=params["hgb_iter"],
-        learning_rate=params["hgb_lr"],
-        max_leaf_nodes=params["hgb_leaves"],
-        l2_regularization=params["hgb_l2"],
-        random_state=42
-    )
+# ============================================================
+# MODEL
+# ============================================================
 
-    logistic = Pipeline([
+def create_model(C):
+
+    model = Pipeline([
         ("scaler", StandardScaler()),
-        ("model", LogisticRegression(
-            C=params["logistic_c"],
-            max_iter=1500,
-            class_weight="balanced",
+
+        ("classifier", LogisticRegression(
+            C=C,
+            max_iter=2000,
+            solver="lbfgs",
+            class_weight=None,
             random_state=42
         ))
     ])
 
-    return [extra, hist, logistic]
-
+    return model
 
-def ensemble_predict(X_train, y_train, X_test, params):
 
-    probabilities = []
+def get_probability(model, X):
 
-    for model in create_models(params):
+    probabilities = model.predict_proba(X)
 
-        model.fit(X_train, y_train)
-
-        probability = model.predict_proba(X_test)[:, 1]
+    classes = list(
+        model.named_steps["classifier"].classes_
+    )
 
-        probabilities.append(probability)
+    positive_index = classes.index(1)
 
-    return np.mean(probabilities, axis=0)
+    return probabilities[:, positive_index]
 
 
-# =========================================================
-# BACKTEST
-# =========================================================
+# ============================================================
+# 2R BACKTEST ENGINE
+# ============================================================
 
-def run_backtest(
+def simulate_trades(
     raw,
-    test,
+    dataset,
+    row_indices,
     probabilities,
-    horizon,
     threshold,
-    atr_multiplier,
-    fee_pct
+    stop_multiplier,
+    horizon,
+    fee_rate,
+    slippage_bps
 ):
 
     trades = []
 
-    fee_rate = fee_pct / 100
+    if len(row_indices) == 0:
+        return trades
+
+    last_validation_raw_i = int(
+        dataset.iloc[row_indices[-1]]["raw_i"]
+    )
+
+    cost = (
+        2 * fee_rate +
+        2 * slippage_bps / 10000
+    )
+
+    for row_position, probability in zip(
+        row_indices,
+        probabilities
+    ):
 
-    next_allowed = -1
+        row = dataset.iloc[row_position]
 
-    raw_positions = raw.index.get_indexer(test.index)
+        raw_i = int(row["raw_i"])
 
-    for i, (timestamp, row) in enumerate(test.iterrows()):
+        # Sinyalden sonraki mumda giriş.
+        entry_i = raw_i + 1
 
-        position = raw_positions[i]
+        # Tam horizon boyunca veri bulunmalı.
+        exit_limit = entry_i + horizon - 1
 
-        if position < 0 or position < next_allowed:
+        if exit_limit > last_validation_raw_i:
             continue
 
-        probability = float(probabilities[i])
+        if exit_limit >= len(raw):
+            continue
 
         if probability >= threshold:
-            side = "LONG"
+
+            direction = 1
 
         elif probability <= 1 - threshold:
-            side = "SHORT"
+
+            direction = -1
 
         else:
+
             continue
 
-        entry = float(row["close"])
-        atr = float(row["atr"])
+        entry_price = float(
+            raw.iloc[entry_i]["open"]
+        )
+
+        volatility = float(row["rv_24"])
 
-        if not np.isfinite(atr) or atr <= 0:
+        if not np.isfinite(volatility) or volatility <= 0:
             continue
 
-        risk = atr * atr_multiplier
+        risk_pct = (
+            volatility *
+            np.sqrt(horizon) *
+            stop_multiplier
+        )
+
+        risk_pct = np.clip(
+            risk_pct,
+            0.002,
+            0.05
+        )
+
+        risk_distance = entry_price * risk_pct
+
+        if direction == 1:
+
+            stop_price = (
+                entry_price - risk_distance
+            )
+
+            target_price = (
+                entry_price + 2 * risk_distance
+            )
 
-        if side == "LONG":
-            stop = entry - risk
-            target = entry + 2 * risk
         else:
-            stop = entry + risk
-            target = entry - 2 * risk
 
-        future = raw.iloc[
-            position + 1:
-            position + horizon + 1
-        ]
+            stop_price = (
+                entry_price + risk_distance
+            )
 
-        if len(future) < horizon:
-            continue
+            target_price = (
+                entry_price - 2 * risk_distance
+            )
+
+        exit_price = None
+        exit_reason = "TIME"
 
-        exit_price = float(future["close"].iloc[-1])
-        exit_reason = "HORIZON"
+        for j in range(entry_i, exit_limit + 1):
 
-        for candle in future.itertuples():
+            candle = raw.iloc[j]
 
-            high = float(candle.high)
-            low = float(candle.low)
+            high = float(candle["high"])
+            low = float(candle["low"])
 
-            if side == "LONG":
+            if direction == 1:
 
-                if low <= stop:
-                    exit_price = stop
-                    exit_reason = "STOP"
-                    break
+                hit_stop = low <= stop_price
 
-                if high >= target:
-                    exit_price = target
-                    exit_reason = "TARGET"
-                    break
+                hit_target = high >= target_price
 
             else:
 
-                if high >= stop:
-                    exit_price = stop
-                    exit_reason = "STOP"
-                    break
+                hit_stop = high >= stop_price
+
+                hit_target = low <= target_price
+
+            # Aynı mumda stop ve hedef:
+            # Muhafazakâr varsayım: STOP önce.
+            if hit_stop:
+
+                exit_price = stop_price
 
-                if low <= target:
-                    exit_price = target
-                    exit_reason = "TARGET"
-                    break
+                exit_reason = "STOP"
+
+                break
+
+            if hit_target:
+
+                exit_price = target_price
+
+                exit_reason = "TARGET"
+
+                break
+
+        if exit_price is None:
+
+            exit_price = float(
+                raw.iloc[exit_limit]["close"]
+            )
+
+        if direction == 1:
+
+            gross_return = (
+                exit_price / entry_price
+            ) - 1
 
-        if side == "LONG":
-            gross = (exit_price - entry) / entry
         else:
-            gross = (entry - exit_price) / entry
 
-        # Giriş ve çıkış komisyonu
-        net = gross - 2 * fee_rate
+            gross_return = (
+                entry_price / exit_price
+            ) - 1
+
+        net_return = gross_return - cost
 
         trades.append({
-            "time": timestamp,
-            "side": side,
-            "entry": entry,
+            "direction": "LONG" if direction == 1 else "SHORT",
+            "probability": float(probability),
+            "entry": entry_price,
             "exit": exit_price,
-            "probability": probability,
-            "net_pct": net * 100,
-            "result": "WIN" if net > 0 else "LOSS",
-            "exit_reason": exit_reason
+            "reason": exit_reason,
+            "gross_return": gross_return,
+            "net_return": net_return
         })
 
-        next_allowed = position + horizon
+    return trades
+
+
+# ============================================================
+# BACKTEST METRICS
+# ============================================================
+
+def calculate_metrics(trades):
 
     if not trades:
 
         return {
-            "count": 0,
-            "winrate": 0,
-            "profit_factor": 0,
-            "total_return": 0,
-            "max_drawdown": 0,
-            "trades": []
+            "trades": 0,
+            "win_rate": 0.0,
+            "profit_factor": 0.0,
+            "net_return": 0.0,
+            "max_drawdown": 0.0
         }
 
-    trade_df = pd.DataFrame(trades)
+    returns = np.array([
+        t["net_return"] for t in trades
+    ])
 
-    wins = trade_df.loc[
-        trade_df["net_pct"] > 0,
-        "net_pct"
-    ]
+    wins = returns[returns > 0]
 
-    losses = trade_df.loc[
-        trade_df["net_pct"] < 0,
-        "net_pct"
-    ]
+    losses = returns[returns < 0]
 
-    gross_profit = wins.sum()
-    gross_loss = abs(losses.sum())
+    if len(losses):
 
-    if gross_loss > 0:
-        pf = gross_profit / gross_loss
-    elif gross_profit > 0:
-        pf = float("inf")
-    else:
-        pf = 0
+        profit_factor = (
+            wins.sum() / abs(losses.sum())
+        )
+
+    elif len(wins):
+
+        profit_factor = 5.0
 
-    winrate = len(wins) / len(trade_df) * 100
+    else:
 
-    returns = trade_df["net_pct"].values / 100
+        profit_factor = 0.0
 
     equity = np.cumprod(1 + returns)
-    peak = np.maximum.accumulate(equity)
 
-    drawdown = (equity - peak) / peak * 100
+    peak = np.maximum.accumulate(
+        np.insert(equity, 0, 1)
+    )[1:]
+
+    drawdowns = 1 - equity / peak
 
-    total_return = (equity[-1] - 1) * 100
+    max_drawdown = (
+        float(np.max(drawdowns))
+        if len(drawdowns) else 0.0
+    )
 
     return {
-        "count": len(trade_df),
-        "winrate": winrate,
-        "profit_factor": pf,
-        "total_return": total_return,
-        "max_drawdown": abs(float(drawdown.min())),
-        "trades": trades
+        "trades": len(trades),
+
+        "win_rate": (
+            len(wins) / len(trades)
+        ),
+
+        "profit_factor": float(
+            min(profit_factor, 5.0)
+        ),
+
+        "net_return": float(
+            equity[-1] - 1
+        ),
+
+        "max_drawdown": max_drawdown
     }
 
 
-# =========================================================
-# OPTUNA
-# =========================================================
+# ============================================================
+# WALK-FORWARD
+# ============================================================
 
-def optimize_model(
+def walk_forward_validation(
     X,
     y,
+    dataset,
     raw,
     horizon,
-    trials,
-    fee_pct
+    C,
+    threshold,
+    stop_multiplier,
+    fee_rate,
+    slippage_bps
 ):
 
-    if len(X) < 200:
-        raise ValueError(
-            "Optuna için yeterli geliştirme verisi yok. "
-            "Mum sayısını artırın."
+    splitter = TimeSeriesSplit(
+        n_splits=3,
+        gap=horizon
+    )
+
+    all_predictions = []
+    all_targets = []
+    all_trades = []
+
+    fold_reports = []
+
+    for fold, (train_idx, val_idx) in enumerate(
+        splitter.split(X),
+        start=1
+    ):
+
+        model = create_model(C)
+
+        model.fit(
+            X.iloc[train_idx],
+            y.iloc[train_idx]
         )
 
+        probabilities = get_probability(
+            model,
+            X.iloc[val_idx]
+        )
+
+        targets = y.iloc[val_idx].values
+
+        predictions = (
+            probabilities >= 0.5
+        ).astype(int)
+
+        trades = simulate_trades(
+            raw,
+            dataset,
+            val_idx,
+            probabilities,
+            threshold,
+            stop_multiplier,
+            horizon,
+            fee_rate,
+            slippage_bps
+        )
+
+        metrics = calculate_metrics(trades)
+
+        all_predictions.extend(
+            predictions.tolist()
+        )
+
+        all_targets.extend(
+            targets.tolist()
+        )
+
+        all_trades.extend(trades)
+
+        fold_reports.append({
+            "fold": fold,
+            "balanced_accuracy": balanced_accuracy_score(
+                targets,
+                predictions
+            ),
+            **metrics
+        })
+
+    overall = calculate_metrics(all_trades)
+
+    overall["balanced_accuracy"] = (
+        balanced_accuracy_score(
+            all_targets,
+            all_predictions
+        )
+    )
+
+    return overall, fold_reports
+
+
+# ============================================================
+# OPTUNA
+# ============================================================
+
+def optimize_model(
+    X,
+    y,
+    dataset,
+    raw,
+    horizon,
+    fee_rate,
+    slippage_bps,
+    trials
+):
+
     splitter = TimeSeriesSplit(
         n_splits=3,
         gap=horizon
     )
 
-    splits = list(splitter.split(X))
-
     def objective(trial):
 
-        params = {
-            "extra_trees": trial.suggest_int(
-                "extra_trees", 100, 300
-            ),
-            "extra_depth": trial.suggest_int(
-                "extra_depth", 3, 12
-            ),
-            "extra_leaf": trial.suggest_int(
-                "extra_leaf", 2, 10
-            ),
-            "hgb_iter": trial.suggest_int(
-                "hgb_iter", 80, 200
-            ),
-            "hgb_lr": trial.suggest_float(
-                "hgb_lr", 0.01, 0.15, log=True
-            ),
-            "hgb_leaves": trial.suggest_int(
-                "hgb_leaves", 7, 20
-            ),
-            "hgb_l2": trial.suggest_float(
-                "hgb_l2", 0.1, 10, log=True
-            ),
-            "logistic_c": trial.suggest_float(
-                "logistic_c", 0.01, 3, log=True
-            )
-        }
+        C = trial.suggest_float(
+            "C",
+            0.01,
+            30.0,
+            log=True
+        )
 
         threshold = trial.suggest_float(
-            "threshold", 0.53, 0.75
+            "threshold",
+            0.52,
+            0.75
         )
 
-        atr_multiplier = trial.suggest_float(
-            "atr_multiplier", 1.0, 2.5
+        stop_multiplier = trial.suggest_float(
+            "stop_multiplier",
+            0.7,
+            2.5
         )
 
         fold_scores = []
 
-        for train_idx, val_idx in splits:
-
-            X_train = X.iloc[train_idx]
-            X_val = X.iloc[val_idx]
+        for train_idx, val_idx in splitter.split(X):
 
-            y_train = y.iloc[train_idx]
+            model = create_model(C)
 
-            if y_train.nunique() < 2:
-                continue
-
-            probs = ensemble_predict(
-                X_train,
-                y_train,
-                X_val,
-                params
+            model.fit(
+                X.iloc[train_idx],
+                y.iloc[train_idx]
             )
 
-            val_data = pd.DataFrame(
-                index=X_val.index
+            probabilities = get_probability(
+                model,
+                X.iloc[val_idx]
             )
 
-            val_data["close"] = raw.loc[
-                X_val.index, "close"
-            ]
-
-            val_data["atr"] = raw.loc[
-                X_val.index, "atr"
-            ]
-
-            result = run_backtest(
-                raw=raw,
-                test=val_data,
-                probabilities=probs,
-                horizon=horizon,
-                threshold=threshold,
-                atr_multiplier=atr_multiplier,
-                fee_pct=fee_pct
+            trades = simulate_trades(
+                raw,
+                dataset,
+                val_idx,
+                probabilities,
+                threshold,
+                stop_multiplier,
+                horizon,
+                fee_rate,
+                slippage_bps
             )
 
-            if result["count"] < 3:
-                fold_scores.append(-10.0)
-                continue
-
-            pf = result["profit_factor"]
-
-            if np.isinf(pf):
-                pf = 3.0
+            metrics = calculate_metrics(trades)
 
+            # Aşırı az işlem yapan modelleri cezalandır.
             score = (
-                result["total_return"]
-                + min(pf, 3.0) * 3
-                - result["max_drawdown"] * 0.5
+                metrics["net_return"] * 100
+                + min(metrics["profit_factor"], 3) * 1.5
+                - metrics["max_drawdown"] * 40
+                + min(metrics["trades"], 20) * 0.05
             )
 
-            fold_scores.append(score)
+            if metrics["trades"] < 3:
+                score -= 5
 
-        if not fold_scores:
-            return -100.0
+            fold_scores.append(score)
 
         return float(np.mean(fold_scores))
 
     study = optuna.create_study(
         direction="maximize",
-        sampler=optuna.samplers.TPESampler(seed=42)
-    )
-
-    optuna.logging.set_verbosity(
-        optuna.logging.WARNING
+        sampler=optuna.samplers.TPESampler(
+            seed=42
+        )
     )
 
     study.optimize(
@@ -779,572 +995,587 @@ def optimize_model(
         show_progress_bar=False
     )
 
-    best = study.best_params
-
-    params = {
-        "extra_trees": best["extra_trees"],
-        "extra_depth": best["extra_depth"],
-        "extra_leaf": best["extra_leaf"],
-        "hgb_iter": best["hgb_iter"],
-        "hgb_lr": best["hgb_lr"],
-        "hgb_leaves": best["hgb_leaves"],
-        "hgb_l2": best["hgb_l2"],
-        "logistic_c": best["logistic_c"]
-    }
+    return study.best_params, study.best_value
 
-    return (
-        params,
-        best["threshold"],
-        best["atr_multiplier"],
-        study.best_value,
-        len(study.trials)
-    )
 
+# ============================================================
+# HOLDOUT TEST
+# ============================================================
 
-# =========================================================
-# WALK-FORWARD VALIDATION
-# =========================================================
+def independent_holdout(
+    X,
+    y,
+    dataset,
+    raw,
+    horizon,
+    C,
+    threshold,
+    stop_multiplier,
+    fee_rate,
+    slippage_bps
+):
 
-def walk_forward_validation(X, y, params, horizon):
+    n = len(X)
 
-    splitter = TimeSeriesSplit(
-        n_splits=3,
-        gap=horizon
+    split = int(n * 0.80)
+
+    train_end = split - horizon
+
+    if train_end < 300:
+        raise ValueError(
+            "Holdout için yeterli eğitim verisi yok."
+        )
+
+    train_idx = np.arange(0, train_end)
+
+    test_idx = np.arange(split, n)
+
+    model = create_model(C)
+
+    model.fit(
+        X.iloc[train_idx],
+        y.iloc[train_idx]
     )
 
-    scores = []
+    probabilities = get_probability(
+        model,
+        X.iloc[test_idx]
+    )
 
-    for train_idx, test_idx in splitter.split(X):
+    targets = y.iloc[test_idx].values
 
-        X_train = X.iloc[train_idx]
-        X_test = X.iloc[test_idx]
+    predictions = (
+        probabilities >= 0.5
+    ).astype(int)
 
-        y_train = y.iloc[train_idx]
-        y_test = y.iloc[test_idx]
+    trades = simulate_trades(
+        raw,
+        dataset,
+        test_idx,
+        probabilities,
+        threshold,
+        stop_multiplier,
+        horizon,
+        fee_rate,
+        slippage_bps
+    )
 
-        if y_train.nunique() < 2:
-            continue
+    metrics = calculate_metrics(trades)
+
+    metrics["accuracy"] = accuracy_score(
+        targets,
+        predictions
+    )
 
-        probs = ensemble_predict(
-            X_train,
-            y_train,
-            X_test,
-            params
+    metrics["balanced_accuracy"] = (
+        balanced_accuracy_score(
+            targets,
+            predictions
         )
+    )
 
-        predictions = (
-            probs >= 0.5
-        ).astype(int)
+    metrics["brier"] = brier_score_loss(
+        targets,
+        probabilities
+    )
 
-        scores.append(
-            balanced_accuracy_score(
-                y_test,
-                predictions
-            )
-        )
+    return metrics, model, probabilities
 
-    return float(np.mean(scores)) if scores else 0.5
 
+# ============================================================
+# OVERFIT RISK INDICATOR
+# ============================================================
 
-# =========================================================
-# OVERFIT RISK INDEX
-# =========================================================
+def calculate_overfit_risk(
+    wf_metrics,
+    holdout_metrics
+):
 
-def calculate_overfit_index(walk_forward_score, holdout_score):
+    wf_ba = wf_metrics["balanced_accuracy"]
 
-    # Pozitif fark, geliştirme döneminin test döneminden
-    # daha iyi görünmesi anlamına gelir.
-    gap = max(
-        0.0,
-        walk_forward_score - holdout_score
+    holdout_ba = holdout_metrics["balanced_accuracy"]
+
+    wf_pf = wf_metrics["profit_factor"]
+
+    holdout_pf = holdout_metrics["profit_factor"]
+
+    accuracy_gap = max(
+        0,
+        wf_ba - holdout_ba
     )
 
-    # 20 yüzde puanlık farkta 100 puan risk.
-    risk = min(100.0, gap * 500)
+    pf_gap = max(
+        0,
+        wf_pf - holdout_pf
+    )
+
+    risk = max(
+        accuracy_gap * 500,
+        pf_gap * 15
+    )
+
+    risk = float(
+        np.clip(risk, 0, 100)
+    )
 
     if risk < 15:
+
         label = "DÜŞÜK"
+
     elif risk < 35:
+
         label = "ORTA"
+
     elif risk < 60:
+
         label = "YÜKSEK"
+
     else:
+
         label = "ÇOK YÜKSEK"
 
-    return risk, label, gap
+    return risk, label
 
 
-# =========================================================
-# MAIN ANALYSIS
-# =========================================================
+# ============================================================
+# LIVE SIGNAL
+# ============================================================
 
-def analyze(
-    timeframe,
-    candles,
+def generate_live_signal(
+    model,
+    latest,
+    threshold,
     horizon,
-    trials,
-    fee_pct
+    stop_multiplier
 ):
 
-    try:
+    X_live = latest[FEATURE_COLUMNS].astype(float)
 
-        candles = int(candles)
-        horizon = int(horizon)
-        trials = int(trials)
-        fee_pct = float(fee_pct)
+    probability_long = float(
+        get_probability(model, X_live)[0]
+    )
 
-        if candles < 800:
-            return "En az 800 mum seç."
+    probability_short = 1 - probability_long
 
-        if horizon < 1 or horizon > 48:
-            return "Horizon 1-48 arasında olmalı."
+    price = float(latest.iloc[0]["close"])
 
-        if trials < 3 or trials > 100:
-            return "Trial sayısı 3-100 arasında olmalı."
+    volatility = float(
+        latest.iloc[0]["rv_24"]
+    )
 
-        if fee_pct < 0 or fee_pct > 1:
-            return "Komisyon değeri geçersiz."
+    risk_pct = (
+        volatility *
+        np.sqrt(horizon) *
+        stop_multiplier
+    )
 
-        # FETCH
-        raw = fetch_data(
-            timeframe=timeframe,
-            candles=candles
-        )
+    risk_pct = float(
+        np.clip(risk_pct, 0.002, 0.05)
+    )
 
-        indicators = calculate_indicators(raw)
+    risk_distance = price * risk_pct
 
-        data = prepare_dataset(
-            raw,
-            horizon
-        )
+    if probability_long >= threshold:
 
-        X = data[FEATURES]
-        y = data["target"].astype(int)
+        signal = "LONG"
 
-        if y.nunique() < 2:
-            return "Veri setinde iki hedef sınıfı bulunmalı."
+        stop = price - risk_distance
 
-        # HOLDOUT SPLIT
-        split = int(len(data) * 0.80)
+        target = price + 2 * risk_distance
 
-        # Horizon kadar purge: train etiketleri
-        # holdout dönemine taşmasın.
-        dev_end = split - horizon
+    elif probability_short >= threshold:
 
-        if dev_end < 200:
-            return (
-                "Geliştirme verisi yetersiz. "
-                "Mum sayısını artırın veya horizon'u azaltın."
-            )
+        signal = "SHORT"
 
-        X_dev = X.iloc[:dev_end]
-        y_dev = y.iloc[:dev_end]
+        stop = price + risk_distance
 
-        X_test = X.iloc[split:]
-        y_test = y.iloc[split:]
+        target = price - 2 * risk_distance
 
-        if y_dev.nunique() < 2 or y_test.nunique() < 2:
-            return (
-                "Eğitim veya hold-out döneminde iki sınıf da "
-                "bulunmalı. Daha fazla mum deneyin."
-            )
+    else:
 
-        # OPTUNA
-        params, threshold, atr_mult, best_score, n_trials = (
-            optimize_model(
-                X=X_dev,
-                y=y_dev,
-                raw=indicators,
-                horizon=horizon,
-                trials=trials,
-                fee_pct=fee_pct
-            )
-        )
+        signal = "NO TRADE"
 
-        # WALK FORWARD
-        wf_score = walk_forward_validation(
-            X_dev,
-            y_dev,
-            params,
-            horizon
-        )
+        stop = None
 
-        # HOLDOUT PREDICTION
-        test_probs = ensemble_predict(
-            X_dev,
-            y_dev,
-            X_test,
-            params
-        )
+        target = None
 
-        test_predictions = (
-            test_probs >= 0.5
-        ).astype(int)
+    return {
+        "signal": signal,
+        "long": probability_long,
+        "short": probability_short,
+        "price": price,
+        "stop": stop,
+        "target": target,
+        "risk_pct": risk_pct
+    }
 
-        accuracy = accuracy_score(
-            y_test,
-            test_predictions
-        )
 
-        balanced = balanced_accuracy_score(
-            y_test,
-            test_predictions
-        )
+# ============================================================
+# MAIN APPLICATION
+# ============================================================
 
-        try:
-            auc = roc_auc_score(
-                y_test,
-                test_probs
-            )
-        except Exception:
-            auc = 0.5
+def run_quant(
+    candle_count,
+    horizon,
+    trials,
+    fee_percent,
+    slippage_bps
+):
+
+    try:
 
-        # HOLDOUT BACKTEST
-        test_data = pd.DataFrame(
-            index=X_test.index
+        optuna.logging.set_verbosity(
+            optuna.logging.WARNING
         )
 
-        test_data["close"] = indicators.loc[
-            X_test.index, "close"
-        ]
+        fee_rate = fee_percent / 100
 
-        test_data["atr"] = indicators.loc[
-            X_test.index, "atr"
-        ]
+        # ----------------------------------------------------
+        # FETCH
+        # ----------------------------------------------------
 
-        backtest = run_backtest(
-            raw=indicators,
-            test=test_data,
-            probabilities=test_probs,
-            horizon=horizon,
-            threshold=threshold,
-            atr_multiplier=atr_mult,
-            fee_pct=fee_pct
+        raw = fetch_data(
+            int(candle_count)
         )
 
-        # OVERFIT INDEX
-        overfit_score, overfit_label, overfit_gap = (
-            calculate_overfit_index(
-                wf_score,
-                balanced
-            )
+        # ----------------------------------------------------
+        # FEATURES
+        # ----------------------------------------------------
+
+        X, y, dataset, live_features = prepare_dataset(
+            raw,
+            int(horizon)
         )
 
-        # FINAL MODEL
-        # Holdout evaluation tamamlandıktan sonra
-        # güncel sinyal için tüm bilinen etiketler kullanılır.
-        final_models = create_models(params)
+        # raw_i değerleri orijinal mum pozisyonlarıdır.
+        # Backtest bu indeksleri kullanır.
 
-        latest_indicators = indicators.dropna(
-            subset=FEATURES + ["atr"]
-        )
+        # ----------------------------------------------------
+        # DEVELOPMENT / HOLDOUT SEPARATION
+        # ----------------------------------------------------
 
-        latest = latest_indicators.iloc[-1]
+        split = int(len(X) * 0.80)
 
-        latest_X = pd.DataFrame(
-            [latest[FEATURES].values],
-            columns=FEATURES
-        )
+        development_end = split - int(horizon)
 
-        final_probabilities = []
+        X_dev = X.iloc[:development_end].reset_index(
+            drop=True
+        )
 
-        for model in final_models:
+        y_dev = y.iloc[:development_end].reset_index(
+            drop=True
+        )
 
-            model.fit(X, y)
+        dev_dataset = dataset.iloc[
+            :development_end
+        ].reset_index(drop=True)
 
-            final_probabilities.append(
-                model.predict_proba(latest_X)[:, 1][0]
+        if len(X_dev) < 500:
+            raise ValueError(
+                "Optimizasyon için geliştirme verisi yetersiz."
             )
 
-        p_up = float(np.mean(final_probabilities))
-        p_down = 1 - p_up
-
-        if p_up >= threshold:
-            signal = "LONG"
-        elif p_down >= threshold:
-            signal = "SHORT"
-        else:
-            signal = "NÖTR"
+        # ----------------------------------------------------
+        # OPTUNA
+        # ----------------------------------------------------
 
-        entry = float(latest["close"])
-        atr = float(latest["atr"])
+        best_params, best_score = optimize_model(
+            X_dev,
+            y_dev,
+            dev_dataset,
+            raw,
+            int(horizon),
+            fee_rate,
+            float(slippage_bps),
+            int(trials)
+        )
 
-        if signal == "LONG":
-            stop = entry - atr * atr_mult
-            target = entry + 2 * atr * atr_mult
+        C = best_params["C"]
 
-        elif signal == "SHORT":
-            stop = entry + atr * atr_mult
-            target = entry - 2 * atr * atr_mult
+        threshold = best_params["threshold"]
 
-        else:
-            stop = None
-            target = None
+        stop_multiplier = best_params["stop_multiplier"]
 
-        # INDICATORS
-        rsi = float(latest["rsi"])
+        # ----------------------------------------------------
+        # WALK FORWARD
+        # ----------------------------------------------------
 
-        macd_state = (
-            "BULLISH"
-            if latest["macd"] > latest["macd_signal"]
-            else "BEARISH"
+        wf_metrics, fold_reports = walk_forward_validation(
+            X_dev,
+            y_dev,
+            dev_dataset,
+            raw,
+            int(horizon),
+            C,
+            threshold,
+            stop_multiplier,
+            fee_rate,
+            float(slippage_bps)
         )
 
-        supertrend_state = (
-            "BULLISH"
-            if latest["supertrend_direction"] == 1
-            else "BEARISH"
+        # ----------------------------------------------------
+        # INDEPENDENT HOLDOUT
+        # ----------------------------------------------------
+
+        holdout_metrics, holdout_model, holdout_probs = (
+            independent_holdout(
+                X,
+                y,
+                dataset,
+                raw,
+                int(horizon),
+                C,
+                threshold,
+                stop_multiplier,
+                fee_rate,
+                float(slippage_bps)
+            )
         )
 
-        vwap_state = (
-            "ÜSTÜNDE"
-            if latest["vwap_distance"] > 0
-            else "ALTINDA"
+        # ----------------------------------------------------
+        # OVERFIT RISK
+        # ----------------------------------------------------
+
+        overfit_score, overfit_label = (
+            calculate_overfit_risk(
+                wf_metrics,
+                holdout_metrics
+            )
         )
 
-        # 4 INDICATOR CONFLUENCE
-        votes = [
-            1 if latest["supertrend_direction"] == 1 else -1,
-            1 if latest["macd"] > latest["macd_signal"] else -1,
-            1 if rsi >= 50 else -1,
-            1 if latest["vwap_distance"] > 0 else -1
-        ]
+        # ----------------------------------------------------
+        # FINAL LIVE MODEL
+        # ----------------------------------------------------
 
-        bullish_votes = sum(v == 1 for v in votes)
-        bearish_votes = 4 - bullish_votes
+        final_model = create_model(C)
 
-        if bullish_votes >= 3:
-            confluence = "GÜÇLÜ BOĞA UYUMU"
-        elif bearish_votes >= 3:
-            confluence = "GÜÇLÜ AYI UYUMU"
-        else:
-            confluence = "KARARSIZ / KARIŞIK"
+        final_model.fit(
+            X,
+            y
+        )
 
-        pf = backtest["profit_factor"]
+        latest = live_features.tail(1)
 
-        pf_text = (
-            "∞" if np.isinf(pf)
-            else f"{pf:.2f}"
+        signal = generate_live_signal(
+            final_model,
+            latest,
+            threshold,
+            int(horizon),
+            stop_multiplier
         )
 
-        stop_text = (
-            f"{stop:,.2f}" if stop is not None else "—"
-        )
+        # ----------------------------------------------------
+        # REPORT
+        # ----------------------------------------------------
 
-        target_text = (
-            f"{target:,.2f}" if target is not None else "—"
+        last_time = pd.to_datetime(
+            latest.iloc[0]["timestamp"],
+            unit="ms",
+            utc=True
         )
 
-        trade_table = "İşlem oluşmadı."
+        report = f"""
+# BTC/USDT QUANT ENGINE
 
-        if backtest["trades"]:
+<badge color="success">OKX CONNECTED</badge>
 
-            trade_df = pd.DataFrame(
-                backtest["trades"]
-            )
+## 1. Veri
 
-            trade_table = trade_df.tail(15).to_markdown(
-                index=False
-            )
+| Metrik | Sonuç |
+|---|---:|
+| Ham mum sayısı | {len(raw)} |
+| Temiz eğitim örneği | {len(X)} |
+| Geliştirme örneği | {len(X_dev)} |
+| Holdout örneği | {len(X) - split} |
+| Zaman dilimi | 1H |
+| Tahmin ufku | {horizon} saat |
+| Son tamamlanmış mum | {last_time} |
 
-        output = f"""
-# OKX BTC/USDT AI ANALİZİ
+## 2. Canlı tahmin
 
-## Güncel sinyal: {signal}
+# {signal['signal']}
 
 | Metrik | Sonuç |
 |---|---:|
-| OKX BTC fiyatı | {entry:,.2f} USDT |
-| LONG olasılığı | {p_up * 100:.2f}% |
-| SHORT olasılığı | {p_down * 100:.2f}% |
-| Sinyal eşiği | {threshold:.3f} |
-| Zaman dilimi | {timeframe} |
-| Tahmin horizon | {horizon} mum |
-
-## Dört indikatör
-
-| İndikatör | Durum |
-|---|---|
-| RSI 14 | {rsi:.2f} |
-| MACD | {macd_state} |
-| Supertrend 10,3 | {supertrend_state} |
-| VWAP | {vwap_state} |
-| İndikatör uyumu | {confluence} |
-| VWAP uzaklığı | {latest['vwap_distance']:.3f}% |
-
-## İşlem seviyeleri
-
-| Seviye | Fiyat |
-|---|---:|
-| Giriş | {entry:,.2f} |
-| Stop Loss | {stop_text} |
-| 2R hedef | {target_text} |
-| ATR çarpanı | {atr_mult:.2f} |
+| BTC fiyatı | {signal['price']:,.2f} USDT |
+| LONG olasılığı | %{signal['long'] * 100:.2f} |
+| SHORT olasılığı | %{signal['short'] * 100:.2f} |
+| Stop mesafesi | %{signal['risk_pct'] * 100:.3f} |
+| Stop-loss | {f"{signal['stop']:,.2f}" if signal['stop'] else "Yok"} |
+| 2R hedef | {f"{signal['target']:,.2f}" if signal['target'] else "Yok"} |
 
-## Optuna
+## 3. Walk-forward sonuçları
 
 | Metrik | Sonuç |
 |---|---:|
-| Trial sayısı | {n_trials} |
-| En iyi objective | {best_score:.4f} |
-| Sinyal eşiği | {threshold:.3f} |
-| ATR çarpanı | {atr_mult:.2f} |
+| Balanced Accuracy | %{wf_metrics['balanced_accuracy'] * 100:.2f} |
+| Win Rate | %{wf_metrics['win_rate'] * 100:.2f} |
+| Profit Factor | {wf_metrics['profit_factor']:.2f} |
+| Net getiri | %{wf_metrics['net_return'] * 100:.2f} |
+| Max Drawdown | %{wf_metrics['max_drawdown'] * 100:.2f} |
+| İşlem sayısı | {wf_metrics['trades']} |
 
-## Bağımsız hold-out test
+## 4. Bağımsız holdout backtest
 
 | Metrik | Sonuç |
 |---|---:|
-| Accuracy | {accuracy * 100:.2f}% |
-| Balanced Accuracy | {balanced * 100:.2f}% |
-| AUC | {auc:.4f} |
-| Walk-forward Balanced Accuracy | {wf_score * 100:.2f}% |
+| Accuracy | %{holdout_metrics['accuracy'] * 100:.2f} |
+| Balanced Accuracy | %{holdout_metrics['balanced_accuracy'] * 100:.2f} |
+| Brier Score | {holdout_metrics['brier']:.4f} |
+| Win Rate | %{holdout_metrics['win_rate'] * 100:.2f} |
+| Profit Factor | {holdout_metrics['profit_factor']:.2f} |
+| Net getiri | %{holdout_metrics['net_return'] * 100:.2f} |
+| Max Drawdown | %{holdout_metrics['max_drawdown'] * 100:.2f} |
+| İşlem sayısı | {holdout_metrics['trades']} |
 
-## OVERFIT RISK INDEX
+## 5. Overfit analizi
 
-# {overfit_score:.1f} / 100 — {overfit_label}
+# {overfit_label}
 
-| Ölçüm | Sonuç |
-|---|---:|
-| Walk-forward başarı | {wf_score * 100:.2f}% |
-| Hold-out başarı | {balanced * 100:.2f}% |
-| Başarı farkı | {overfit_gap * 100:.2f} yüzde puan |
+**Overfit risk puanı: {overfit_score:.1f}/100**
 
-Risk yorumu:
-- 0–14: Düşük gözlenen genelleme farkı
-- 15–34: Orta
-- 35–59: Yüksek
-- 60–100: Çok yüksek
+Bu puan walk-forward ve holdout sonuçları arasındaki farktan üretilen sezgisel bir göstergedir. İstatistiksel olarak kalibre edilmiş bir olasılık değildir.
 
-## Hold-out backtest
+## 6. Optuna parametreleri
 
-| Metrik | Sonuç |
+| Parametre | Değer |
 |---|---:|
-| İşlem sayısı | {backtest['count']} |
-| Win Rate | {backtest['winrate']:.2f}% |
-| Profit Factor | {pf_text} |
-| Bileşik net getiri | {backtest['total_return']:.2f}% |
-| Maksimum drawdown | {backtest['max_drawdown']:.2f}% |
-| Komisyon | %{fee_pct:.3f} / taraf |
+| Logistic C | {C:.5f} |
+| Long/Short eşik | %{threshold * 100:.2f} |
+| Stop çarpanı | {stop_multiplier:.3f} |
+| Optuna en iyi skor | {best_score:.4f} |
+| Deneme sayısı | {trials} |
 
-## Son backtest işlemleri
+## 7. Walk-forward fold sonuçları
 
-{trade_table}
+| Fold | Balanced Acc. | Win Rate | PF | Net Getiri | İşlem |
+|---|---:|---:|---:|---:|---:|
+"""
+
+        for f in fold_reports:
 
-## Optuna model parametreleri
+            report += (
+                f"| {f['fold']} "
+                f"| %{f['balanced_accuracy'] * 100:.2f} "
+                f"| %{f['win_rate'] * 100:.2f} "
+                f"| {f['profit_factor']:.2f} "
+                f"| %{f['net_return'] * 100:.2f} "
+                f"| {f['trades']} |\\n"
+            )
 
-```text
-{params}
-```
+        report += """
 
 ---
 
-**Overfit uyarısı:** Bu risk endeksi kesin bir overfit testi değildir. Walk-forward ve hold-out Balanced Accuracy arasındaki farktan türetilen bir göstergedir. Küçük fark, modelin overfit olmadığını kanıtlamaz.
+### Model hakkında
 
-**Backtest uyarısı:** Mum içindeki fiyat sırası bilinmediği için aynı mumda stop ve hedef görülürse stop önce varsayılır. Funding, spread, slippage ve gerçek emir gerçekleşmesi dahil değildir. Sonuçlar canlı kazanç garantisi değildir.
+- Teknik indikatör kullanılmadı.
+- Tahmin modeli Logistic Regression.
+- Özellikler fiyat, hacim ve istatistiksel matematikten üretildi.
+- Optuna yalnızca geliştirme verisinde çalıştı.
+- Holdout, optimizasyon sırasında kullanılmadı.
+- Stop ve hedef 1:2 risk/getiri oranına göre hesaplandı.
+
+**Risk notu:** Bu backtestte fonlama, gerçek spread, likidasyon, piyasa derinliği ve emir kayması tam olarak modellenmez. Sonuçlar gerçek işlem performansını garanti etmez.
 """
 
-        return output
+        return report
 
     except Exception as e:
 
         return (
-            "# ANALİZ HATASI\n\n"
+            "# UYGULAMA HATASI\n\n"
             f"`{type(e).__name__}: {str(e)}`\n\n"
-            "OKX bağlantısını, mum sayısını ve timeframe ayarını kontrol et."
+            "OKX bağlantısını, veri sayısını ve parametreleri kontrol et."
         )
 
 
-# =========================================================
+# ============================================================
 # GRADIO UI
-# =========================================================
+# ============================================================
 
 with gr.Blocks(
-    title="OKX BTC AI Optuna Overfit Monitor"
-) as app:
+    title="OKX BTC Quant Engine",
+    theme=gr.themes.Soft()
+) as demo:
 
     gr.Markdown(
         """
-# OKX BTC AI — OPTUNA + BACKTEST + OVERFIT MONITOR
+# BTC/USDT Quant Engine
 
-OKX perpetual swap verisiyle çalışan ML ensemble.
+**Pure Mathematics · OKX Swap · 1 Hour**
 
-**Supertrend + RSI + MACD + VWAP + Optuna + Walk-forward**
+RSI, MACD, EMA, VWAP veya Supertrend yok.
+Sadece matematiksel fiyat ve hacim analizi.
 """
     )
 
     with gr.Row():
 
-        timeframe = gr.Dropdown(
-            choices=[
-                "5m",
-                "15m",
-                "30m",
-                "1h",
-                "4h",
-                "1d"
-            ],
-            value="1h",
-            label="Timeframe"
-        )
-
-        candles = gr.Dropdown(
-            choices=[
-                1000,
-                1500,
-                2000,
-                3000,
-                4000,
-                5000
-            ],
-            value=2000,
-            label="OKX mum sayısı"
+        candle_count = gr.Slider(
+            minimum=1000,
+            maximum=5000,
+            value=3000,
+            step=500,
+            label="OKX Mum Sayısı"
         )
 
-    with gr.Row():
-
         horizon = gr.Slider(
-            minimum=1,
+            minimum=2,
             maximum=24,
             value=6,
             step=1,
-            label="Tahmin horizon (mum)"
+            label="Tahmin Ufku (Saat)"
         )
 
+    with gr.Row():
+
         trials = gr.Slider(
-            minimum=3,
-            maximum=100,
-            value=20,
-            step=1,
-            label="Optuna trial sayısı"
+            minimum=5,
+            maximum=50,
+            value=15,
+            step=5,
+            label="Optuna Deneme Sayısı"
         )
 
-        fee = gr.Slider(
+        fee_percent = gr.Slider(
             minimum=0,
             maximum=0.20,
             value=0.05,
             step=0.01,
-            label="Komisyon (%) / taraf"
+            label="Komisyon (%) / Taraf"
+        )
+
+        slippage_bps = gr.Slider(
+            minimum=0,
+            maximum=20,
+            value=2,
+            step=1,
+            label="Kayma (baz puan) / Taraf"
         )
 
     run_button = gr.Button(
-        "OKX AI ANALİZ + OPTUNA BACKTEST",
+        "QUANT ANALİZİ BAŞLAT",
         variant="primary"
     )
 
     output = gr.Markdown()
 
     run_button.click(
-        fn=analyze,
+        fn=run_quant,
         inputs=[
-            timeframe,
-            candles,
+            candle_count,
             horizon,
             trials,
-            fee
+            fee_percent,
+            slippage_bps
         ],
         outputs=output
     )
 
 
 if __name__ == "__main__":
-    app.launch()
+
+    demo.queue()
+
+    demo.launch()