Update app.py

app.py

@@ -9,15 +9,7 @@ import ccxt
 import gradio as gr
 import optuna
 
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import (
-    accuracy_score,
-    balanced_accuracy_score,
-    brier_score_loss
-)
-from sklearn.model_selection import TimeSeriesSplit
+from hmmlearn.hmm import GaussianHMM
 
 
 # ============================================================
@@ -28,42 +20,18 @@ 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",
-
-    "skew_48", "kurt_48",
-    "autocorr_48",
-
-    "hurst_64",
-    "entropy_48",
-
-    "kalman_gap",
-    "kalman_trend_6",
-    "kalman_innovation",
-
-    "volume_change",
-    "volume_zscore",
-    "volume_price_corr"
+HMM_COLUMNS = [
+    "log_return",
+    "realized_volatility",
+    "range_return"
 ]
 
 
 # ============================================================
-# OKX CONNECTION
+# OKX DATA
 # ============================================================
 
-def create_exchange():
+def fetch_data(candle_count):
 
     exchange = ccxt.okx({
         "enableRateLimit": True,
@@ -73,30 +41,19 @@ def create_exchange():
         }
     })
 
-    return exchange
-
-
-def fetch_data(candle_count):
-
-    exchange = create_exchange()
-
     exchange.load_markets()
 
     if SYMBOL not in exchange.markets:
-        raise ValueError(
-            f"OKX piyasasında {SYMBOL} bulunamadı."
-        )
+        raise ValueError(f"{SYMBOL} OKX piyasasında bulunamadı.")
 
     now = exchange.milliseconds()
 
     since = now - (candle_count + 20) * TIMEFRAME_MS
 
-    all_candles = []
+    candles = []
     cursor = since
 
-    max_requests = int(candle_count / 100) + 15
-
-    for _ in range(max_requests):
+    for _ in range(int(candle_count / 100) + 20):
 
         batch = exchange.fetch_ohlcv(
             SYMBOL,
@@ -108,7 +65,7 @@ def fetch_data(candle_count):
         if not batch:
             break
 
-        all_candles.extend(batch)
+        candles.extend(batch)
 
         last_timestamp = batch[-1][0]
 
@@ -117,7 +74,7 @@ def fetch_data(candle_count):
 
         cursor = last_timestamp + TIMEFRAME_MS
 
-        if len(all_candles) >= candle_count + 100:
+        if len(candles) >= candle_count + 100:
             break
 
         if last_timestamp >= now - TIMEFRAME_MS:
@@ -125,11 +82,11 @@ def fetch_data(candle_count):
 
         time.sleep(exchange.rateLimit / 1000)
 
-    if not all_candles:
+    if not candles:
         raise ValueError("OKX veri döndürmedi.")
 
     df = pd.DataFrame(
-        all_candles,
+        candles,
         columns=[
             "timestamp",
             "open",
@@ -140,419 +97,486 @@ def fetch_data(candle_count):
         ]
     )
 
-    df = df.drop_duplicates(
-        subset=["timestamp"]
-    )
-
+    df = df.drop_duplicates("timestamp")
     df = df.sort_values("timestamp")
 
-    # Henüz tamamlanmamış mumları çıkar.
     now = exchange.milliseconds()
 
+    # Yalnızca tamamlanmış mumlar
     df = df[
         df["timestamp"] + TIMEFRAME_MS <= now
-    ]
+    ].copy()
 
     df = df.tail(candle_count).reset_index(drop=True)
 
     for col in ["open", "high", "low", "close", "volume"]:
-        df[col] = pd.to_numeric(
-            df[col],
-            errors="coerce"
-        )
-
-    df = df.replace(
-        [np.inf, -np.inf],
-        np.nan
-    )
+        df[col] = pd.to_numeric(df[col], errors="coerce")
 
+    df = df.replace([np.inf, -np.inf], np.nan)
     df = df.dropna().reset_index(drop=True)
 
     df = df[
         (df["close"] > 0) &
-        (df["high"] >= df["low"]) &
-        (df["volume"] >= 0)
+        (df["high"] >= df["low"])
     ].reset_index(drop=True)
 
     if len(df) < 500:
         raise ValueError(
-            f"Yeterli OKX verisi yok. Gelen mum: {len(df)}"
+            f"Yeterli mum yok. Gelen: {len(df)}"
         )
 
     return df
 
 
 # ============================================================
-# MATHEMATICAL FUNCTIONS
+# MATHEMATICAL FEATURES
+# No RSI / MACD / EMA / VWAP
 # ============================================================
 
-def safe_div(a, b):
+def create_features(raw):
 
-    return a / (b.replace(0, np.nan) if isinstance(b, pd.Series) else b)
+    df = raw.copy()
 
+    log_close = np.log(df["close"])
 
-def shannon_entropy(values):
+    returns = log_close.diff()
 
-    x = np.asarray(values)
+    df["log_return"] = returns
 
-    signs = np.sign(x)
+    # HMM observations
+    df["realized_volatility"] = (
+        returns.rolling(24).std()
+    )
 
-    counts = np.bincount(
-        (signs + 1).astype(int),
-        minlength=3
+    df["range_return"] = np.log(
+        df["high"] / df["low"]
     )
 
-    probabilities = counts / counts.sum()
+    # Bayesian analysis auxiliary statistics
+    df["return_6"] = (
+        log_close - log_close.shift(6)
+    )
 
-    probabilities = probabilities[
-        probabilities > 0
-    ]
+    df["return_24"] = (
+        log_close - log_close.shift(24)
+    )
 
-    entropy = -np.sum(
-        probabilities * np.log(probabilities)
+    df["volatility_48"] = (
+        returns.rolling(48).std()
     )
 
-    return entropy / np.log(3)
+    df["volume_change"] = np.log1p(
+        df["volume"]
+    ).diff()
 
+    df["volume_volatility"] = (
+        df["volume_change"].rolling(24).std()
+    )
 
-def hurst_exponent(values):
+    df["return_skew"] = (
+        returns.rolling(48).skew()
+    )
 
-    x = np.asarray(values)
+    df["return_kurtosis"] = (
+        returns.rolling(48).kurt()
+    )
 
-    if len(x) < 32:
-        return np.nan
+    df["autocorrelation"] = (
+        returns.rolling(48).corr(
+            returns.shift(1)
+        )
+    )
 
-    lags = np.array([1, 2, 4, 8])
+    df["price_zscore"] = (
+        (log_close - log_close.rolling(48).mean())
+        / log_close.rolling(48).std()
+    )
 
-    tau = []
+    df["raw_i"] = np.arange(len(df))
 
-    for lag in lags:
+    return df.replace(
+        [np.inf, -np.inf],
+        np.nan
+    )
 
-        differences = x[lag:] - x[:-lag]
 
-        value = np.std(differences)
+# ============================================================
+# DATASET
+# ============================================================
 
-        if value <= 0:
-            return np.nan
+def prepare_dataset(raw, horizon):
 
-        tau.append(value)
+    df = create_features(raw)
 
-    slope = np.polyfit(
-        np.log(lags),
-        np.log(tau),
-        1
-    )[0]
+    future_close = df["close"].shift(-horizon)
 
-    return float(np.clip(slope, 0, 1))
+    df["target"] = np.where(
+        future_close.notna(),
+        (future_close > df["close"]).astype(float),
+        np.nan
+    )
 
+    required = (
+        HMM_COLUMNS +
+        [
+            "return_6",
+            "return_24",
+            "volatility_48",
+            "volume_change",
+            "volume_volatility",
+            "return_skew",
+            "return_kurtosis",
+            "autocorrelation",
+            "price_zscore"
+        ]
+    )
 
-def kalman_filter(log_prices):
+    live = df.dropna(
+        subset=required
+    ).copy()
 
-    prices = np.asarray(log_prices)
+    dataset = live.dropna(
+        subset=["target"]
+    ).copy()
 
-    n = len(prices)
+    live = live.reset_index(drop=True)
+    dataset = dataset.reset_index(drop=True)
 
-    filtered = np.zeros(n)
-    innovations = np.zeros(n)
+    if len(dataset) < 500:
+        raise ValueError(
+            f"Temiz veri yetersiz: {len(dataset)}"
+        )
 
-    q = 0.000001
-    r = 0.000025
+    return dataset, live
 
-    estimate = prices[0]
-    variance = 0.001
 
-    for i in range(n):
+# ============================================================
+# HMM SCALER
+# ============================================================
 
-        predicted = estimate
+class HMMRegime:
 
-        predicted_variance = variance + q
+    def __init__(self):
 
-        innovation = prices[i] - predicted
+        self.mean = None
+        self.std = None
+        self.model = None
+        self.order = None
 
-        total_variance = predicted_variance + r
+    def scale_fit(self, X):
 
-        gain = predicted_variance / total_variance
+        self.mean = np.mean(X, axis=0)
 
-        estimate = predicted + gain * innovation
+        self.std = np.std(X, axis=0)
 
-        variance = (1 - gain) * predicted_variance
+        self.std = np.where(
+            self.std < 1e-10,
+            1.0,
+            self.std
+        )
 
-        filtered[i] = estimate
+        return (X - self.mean) / self.std
 
-        innovations[i] = (
-            innovation / np.sqrt(total_variance)
+    def scale_transform(self, X):
+
+        return (X - self.mean) / self.std
+
+    def fit(self, train_df):
+
+        X = train_df[HMM_COLUMNS].values.astype(float)
+
+        X_scaled = self.scale_fit(X)
+
+        self.model = GaussianHMM(
+            n_components=3,
+            covariance_type="diag",
+            n_iter=150,
+            tol=0.001,
+            min_covar=1e-4,
+            random_state=42
         )
 
-    return filtered, innovations
+        self.model.fit(X_scaled)
 
+        # Rejimleri ortalama getirilerine göre sırala.
+        # En düşük: bearish, orta: neutral, en yüksek: bullish.
+        self.order = np.argsort(
+            self.model.means_[:, 0]
+        )
 
-# ============================================================
-# QUANT FEATURE ENGINEERING
-# NO RSI / MACD / EMA / SUPERTREND / VWAP
-# ============================================================
+        return self
 
-def calculate_quant_features(df):
+    def filter(self, df, initial_alpha=None):
 
-    data = df.copy()
+        X = df[HMM_COLUMNS].values.astype(float)
 
-    log_close = np.log(data["close"])
+        X_scaled = self.scale_transform(X)
 
-    log_open = np.log(data["open"])
-    log_high = np.log(data["high"])
-    log_low = np.log(data["low"])
+        model = self.model
 
-    returns = log_close.diff()
+        means = model.means_
 
-    # --------------------------------------------------------
-    # LOG RETURNS
-    # --------------------------------------------------------
+        covars = np.asarray(model.covars_)
 
-    for period in [1, 2, 3, 6, 12, 24, 48, 96]:
+        if covars.ndim == 3:
+            variances = np.diagonal(
+                covars,
+                axis1=1,
+                axis2=2
+            )
+        else:
+            variances = covars
 
-        data[f"ret_{period}"] = (
-            log_close - log_close.shift(period)
+        variances = np.maximum(
+            variances,
+            1e-8
         )
 
-    # --------------------------------------------------------
-    # REALIZED VOLATILITY
-    # --------------------------------------------------------
+        n_components = model.n_components
 
-    for window in [12, 24, 48, 96]:
+        dimension = X_scaled.shape[1]
 
-        data[f"rv_{window}"] = (
-            returns.rolling(window).std()
+        # Gaussian emission log likelihood
+        log_emissions = np.zeros(
+            (len(X_scaled), n_components)
         )
 
-    data["vol_ratio"] = safe_div(
-        data["rv_24"],
-        data["rv_96"]
-    )
+        for state in range(n_components):
 
-    # --------------------------------------------------------
-    # Z-SCORE
-    # --------------------------------------------------------
+            diff = X_scaled - means[state]
 
-    for window in [24, 48]:
+            log_emissions[:, state] = -0.5 * (
+                dimension * np.log(2 * np.pi)
+                + np.sum(np.log(variances[state]))
+                + np.sum(
+                    (diff ** 2) / variances[state],
+                    axis=1
+                )
+            )
 
-        mean = log_close.rolling(window).mean()
+        # Numerically stable forward filtering
+        posterior = []
 
-        std = log_close.rolling(window).std()
+        if initial_alpha is None:
 
-        data[f"zscore_{window}"] = safe_div(
-            log_close - mean,
-            std
-        )
+            alpha = model.startprob_.copy()
 
-    # --------------------------------------------------------
-    # CANDLE DISTRIBUTION MATHEMATICS
-    # --------------------------------------------------------
+        else:
 
-    data["range_pct"] = log_high - log_low
+            alpha = np.asarray(
+                initial_alpha,
+                dtype=float
+            ).copy()
 
-    data["body_pct"] = log_close - log_open
+        transition = model.transmat_
 
-    candle_range = (
-        data["high"] - data["low"]
-    ).replace(0, np.nan)
+        for i in range(len(X_scaled)):
 
-    data["upper_wick"] = (
-        data["high"] -
-        data[["open", "close"]].max(axis=1)
-    ) / candle_range
+            if i > 0 or initial_alpha is not None:
 
-    data["lower_wick"] = (
-        data[["open", "close"]].min(axis=1) -
-        data["low"]
-    ) / candle_range
+                alpha = alpha @ transition
 
-    data["close_position"] = (
-        data["close"] - data["low"]
-    ) / candle_range
+            log_alpha = (
+                np.log(np.maximum(alpha, 1e-300))
+                + log_emissions[i]
+            )
 
-    # --------------------------------------------------------
-    # PARKINSON VOLATILITY ESTIMATOR
-    # --------------------------------------------------------
+            log_alpha -= np.max(log_alpha)
 
-    squared_range = (
-        np.log(data["high"] / data["low"]) ** 2
-    )
+            alpha = np.exp(log_alpha)
 
-    data["parkinson_24"] = np.sqrt(
-        squared_range.rolling(24).mean()
-        / (4 * np.log(2))
-    )
+            total = alpha.sum()
 
-    # --------------------------------------------------------
-    # DISTRIBUTION STATISTICS
-    # --------------------------------------------------------
+            if total <= 0 or not np.isfinite(total):
 
-    data["skew_48"] = returns.rolling(48).skew()
+                alpha = np.ones(n_components) / n_components
 
-    data["kurt_48"] = returns.rolling(48).kurt()
+            else:
 
-    # --------------------------------------------------------
-    # AUTOCORRELATION
-    # --------------------------------------------------------
+                alpha /= total
 
-    data["autocorr_48"] = (
-        returns.rolling(48).corr(returns.shift(1))
-    )
+            posterior.append(alpha.copy())
 
-    # --------------------------------------------------------
-    # HURST EXPONENT
-    # --------------------------------------------------------
+        posterior = np.asarray(posterior)
 
-    data["hurst_64"] = log_close.rolling(
-        64
-    ).apply(
-        hurst_exponent,
-        raw=True
-    )
+        # Stable column order: Bearish, Neutral, Bullish
+        posterior = posterior[:, self.order]
 
-    # --------------------------------------------------------
-    # SHANNON ENTROPY
-    # --------------------------------------------------------
+        last_alpha = (
+            posterior[-1].copy()
+            if len(posterior)
+            else None
+        )
 
-    data["entropy_48"] = returns.rolling(
-        48
-    ).apply(
-        shannon_entropy,
-        raw=True
-    )
+        return posterior, last_alpha
 
-    # --------------------------------------------------------
-    # KALMAN FILTER
-    # --------------------------------------------------------
 
-    filtered, innovations = kalman_filter(
-        log_close.values
-    )
+# ============================================================
+# BAYESIAN REGIME SWITCHING
+# ============================================================
 
-    data["kalman_gap"] = (
-        log_close.values - filtered
-    )
+def bayesian_regime_probability(
+    train_posterior,
+    train_targets,
+    future_posterior,
+    prior_alpha=2.0,
+    prior_beta=2.0
+):
 
-    data["kalman_trend_6"] = (
-        pd.Series(filtered).diff(6).values
-    )
+    # State order:
+    # 0 Bearish, 1 Neutral, 2 Bullish
 
-    data["kalman_innovation"] = innovations
+    regime_probabilities = []
 
-    # --------------------------------------------------------
-    # VOLUME MATHEMATICS
-    # --------------------------------------------------------
+    for state in range(3):
 
-    log_volume = np.log1p(data["volume"])
+        weights = train_posterior[:, state]
 
-    data["volume_change"] = log_volume.diff()
+        positive = np.sum(
+            weights * train_targets
+        )
 
-    volume_mean = log_volume.rolling(48).mean()
+        negative = np.sum(
+            weights * (1 - train_targets)
+        )
 
-    volume_std = log_volume.rolling(48).std()
+        posterior_up = (
+            prior_alpha + positive
+        ) / (
+            prior_alpha + prior_beta
+            + positive + negative
+        )
 
-    data["volume_zscore"] = safe_div(
-        log_volume - volume_mean,
-        volume_std
+        regime_probabilities.append(
+            posterior_up
+        )
+
+    regime_probabilities = np.asarray(
+        regime_probabilities
     )
 
-    data["volume_price_corr"] = (
-        returns.rolling(48).corr(
-            data["volume_change"]
-        )
+    # Bayesian mixture over HMM regime probabilities
+    long_probabilities = (
+        future_posterior @ regime_probabilities
     )
 
-    return data
+    return (
+        long_probabilities,
+        regime_probabilities
+    )
 
 
 # ============================================================
-# DATASET
+# FIT REGIME MODEL AND BAYESIAN PROBABILITY
 # ============================================================
 
-def prepare_dataset(raw, horizon):
+def fit_predict_regimes(train_df, train_y, future_df):
 
-    features = calculate_quant_features(raw)
+    hmm = HMMRegime().fit(train_df)
 
-    features["raw_i"] = np.arange(len(features))
-
-    future_close = features["close"].shift(-horizon)
+    train_posterior, last_alpha = hmm.filter(
+        train_df
+    )
 
-    features["target"] = np.where(
-        future_close.notna(),
-        (future_close > features["close"]).astype(float),
-        np.nan
+    future_posterior, _ = hmm.filter(
+        future_df,
+        initial_alpha=last_alpha
     )
 
-    features = features.replace(
-        [np.inf, -np.inf],
-        np.nan
+    probabilities, regime_probabilities = (
+        bayesian_regime_probability(
+            train_posterior,
+            train_y,
+            future_posterior
+        )
     )
 
-    live_features = features.dropna(
-        subset=FEATURE_COLUMNS
-    ).copy()
+    return {
+        "probabilities": probabilities,
+        "train_posterior": train_posterior,
+        "future_posterior": future_posterior,
+        "regime_probabilities": regime_probabilities,
+        "hmm": hmm
+    }
 
-    dataset = live_features.dropna(
-        subset=["target"]
-    ).copy()
 
-    dataset = dataset.reset_index(drop=True)
+# ============================================================
+# SEQUENTIAL PROBABILITY RATIO TEST
+# ============================================================
 
-    live_features = live_features.reset_index(drop=True)
+def sprt_test(
+    raw,
+    raw_index,
+    window=24,
+    p1=0.60,
+    alpha=0.10,
+    beta=0.10
+):
 
-    if len(dataset) < 500:
-        raise ValueError(
-            "Temiz eğitim verisi 500 örneğin altında. "
-            f"Mevcut: {len(dataset)}"
-        )
+    if raw_index < window:
+        return "INSUFFICIENT", 0.0, 0.0
 
-    X = dataset[FEATURE_COLUMNS].astype(float)
+    returns = np.log(
+        raw["close"].iloc[
+            raw_index - window + 1:raw_index + 1
+        ].values
+    )
 
-    y = dataset["target"].astype(int)
+    returns = np.diff(returns)
 
-    if y.nunique() < 2:
-        raise ValueError(
-            "Eğitim verisinde iki sınıf da bulunmalı."
-        )
+    if len(returns) == 0:
+        return "INSUFFICIENT", 0.0, 0.0
 
-    return X, y, dataset, live_features
+    signs = np.sign(returns)
 
+    up_count = np.sum(signs > 0)
 
-# ============================================================
-# MODEL
-# ============================================================
+    down_count = np.sum(signs < 0)
 
-def create_model(C):
+    # Neutral returns are not counted.
+    p0 = 0.50
 
-    model = Pipeline([
-        ("scaler", StandardScaler()),
+    log_up = np.log(p1 / p0)
 
-        ("classifier", LogisticRegression(
-            C=C,
-            max_iter=2000,
-            solver="lbfgs",
-            class_weight=None,
-            random_state=42
-        ))
-    ])
+    log_down = np.log(
+        (1 - p1) / (1 - p0)
+    )
 
-    return model
+    long_llr = (
+        up_count * log_up
+        + down_count * log_down
+    )
 
+    short_llr = (
+        down_count * log_up
+        + up_count * log_down
+    )
 
-def get_probability(model, X):
+    upper_boundary = np.log(
+        (1 - beta) / alpha
+    )
 
-    probabilities = model.predict_proba(X)
+    if long_llr >= upper_boundary:
 
-    classes = list(
-        model.named_steps["classifier"].classes_
-    )
+        decision = "LONG"
+
+    elif short_llr >= upper_boundary:
 
-    positive_index = classes.index(1)
+        decision = "SHORT"
 
-    return probabilities[:, positive_index]
+    else:
+
+        decision = "NO CONFIRMATION"
+
+    return (
+        decision,
+        float(long_llr),
+        float(short_llr)
+    )
 
 
 # ============================================================
-# 2R BACKTEST ENGINE
+# BACKTEST
 # ============================================================
 
 def simulate_trades(
@@ -564,7 +588,8 @@ def simulate_trades(
     stop_multiplier,
     horizon,
     fee_rate,
-    slippage_bps
+    slippage_bps,
+    sprt_window
 ):
 
     trades = []
@@ -572,36 +597,40 @@ def simulate_trades(
     if len(row_indices) == 0:
         return trades
 
-    last_validation_raw_i = int(
+    last_raw_index = int(
         dataset.iloc[row_indices[-1]]["raw_i"]
     )
 
     cost = (
-        2 * fee_rate +
-        2 * slippage_bps / 10000
+        2 * fee_rate
+        + 2 * slippage_bps / 10000
     )
 
-    for row_position, probability in zip(
+    last_exit_index = -1
+
+    for row_index, probability in zip(
         row_indices,
         probabilities
     ):
 
-        row = dataset.iloc[row_position]
+        row = dataset.iloc[row_index]
 
         raw_i = int(row["raw_i"])
 
-        # Sinyalden sonraki mumda giriş.
         entry_i = raw_i + 1
 
-        # Tam horizon boyunca veri bulunmalı.
         exit_limit = entry_i + horizon - 1
 
-        if exit_limit > last_validation_raw_i:
+        if exit_limit > last_raw_index:
             continue
 
         if exit_limit >= len(raw):
             continue
 
+        # Prevent overlapping positions.
+        if entry_i <= last_exit_index:
+            continue
+
         if probability >= threshold:
 
             direction = 1
@@ -614,11 +643,25 @@ def simulate_trades(
 
             continue
 
+        sprt_decision, long_llr, short_llr = sprt_test(
+            raw,
+            raw_i,
+            window=sprt_window
+        )
+
+        if direction == 1 and sprt_decision != "LONG":
+            continue
+
+        if direction == -1 and sprt_decision != "SHORT":
+            continue
+
         entry_price = float(
             raw.iloc[entry_i]["open"]
         )
 
-        volatility = float(row["rv_24"])
+        volatility = float(
+            row["realized_volatility"]
+        )
 
         if not np.isfinite(volatility) or volatility <= 0:
             continue
@@ -635,30 +678,22 @@ def simulate_trades(
             0.05
         )
 
-        risk_distance = entry_price * risk_pct
+        distance = entry_price * risk_pct
 
         if direction == 1:
 
-            stop_price = (
-                entry_price - risk_distance
-            )
+            stop = entry_price - distance
 
-            target_price = (
-                entry_price + 2 * risk_distance
-            )
+            target = entry_price + 2 * distance
 
         else:
 
-            stop_price = (
-                entry_price + risk_distance
-            )
+            stop = entry_price + distance
 
-            target_price = (
-                entry_price - 2 * risk_distance
-            )
+            target = entry_price - 2 * distance
 
         exit_price = None
-        exit_reason = "TIME"
+        reason = "TIME"
 
         for j in range(entry_i, exit_limit + 1):
 
@@ -669,32 +704,25 @@ def simulate_trades(
 
             if direction == 1:
 
-                hit_stop = low <= stop_price
-
-                hit_target = high >= target_price
+                hit_stop = low <= stop
+                hit_target = high >= target
 
             else:
 
-                hit_stop = high >= stop_price
-
-                hit_target = low <= target_price
+                hit_stop = high >= stop
+                hit_target = low <= target
 
-            # Aynı mumda stop ve hedef:
-            # Muhafazakâr varsayım: STOP önce.
+            # Conservative same-candle assumption.
             if hit_stop:
 
-                exit_price = stop_price
-
-                exit_reason = "STOP"
-
+                exit_price = stop
+                reason = "STOP"
                 break
 
             if hit_target:
 
-                exit_price = target_price
-
-                exit_reason = "TARGET"
-
+                exit_price = target
+                reason = "TARGET"
                 break
 
         if exit_price is None:
@@ -705,33 +733,33 @@ def simulate_trades(
 
         if direction == 1:
 
-            gross_return = (
-                exit_price / entry_price
-            ) - 1
+            gross = exit_price / entry_price - 1
 
         else:
 
-            gross_return = (
-                entry_price / exit_price
-            ) - 1
+            gross = entry_price / exit_price - 1
 
-        net_return = gross_return - cost
+        net = gross - cost
 
         trades.append({
             "direction": "LONG" if direction == 1 else "SHORT",
-            "probability": float(probability),
             "entry": entry_price,
             "exit": exit_price,
-            "reason": exit_reason,
-            "gross_return": gross_return,
-            "net_return": net_return
+            "probability": float(probability),
+            "long_llr": long_llr,
+            "short_llr": short_llr,
+            "reason": reason,
+            "gross_return": gross,
+            "net_return": net
         })
 
+        last_exit_index = exit_limit
+
     return trades
 
 
 # ============================================================
-# BACKTEST METRICS
+# METRICS
 # ============================================================
 
 def calculate_metrics(trades):
@@ -740,13 +768,13 @@ def calculate_metrics(trades):
 
         return {
             "trades": 0,
-            "win_rate": 0.0,
-            "profit_factor": 0.0,
-            "net_return": 0.0,
-            "max_drawdown": 0.0
+            "win_rate": 0,
+            "profit_factor": 0,
+            "net_return": 0,
+            "max_drawdown": 0
         }
 
-    returns = np.array([
+    returns = np.asarray([
         t["net_return"] for t in trades
     ])
 
@@ -756,47 +784,30 @@ def calculate_metrics(trades):
 
     if len(losses):
 
-        profit_factor = (
-            wins.sum() / abs(losses.sum())
-        )
+        pf = wins.sum() / abs(losses.sum())
 
     elif len(wins):
 
-        profit_factor = 5.0
+        pf = 5.0
 
     else:
 
-        profit_factor = 0.0
+        pf = 0.0
 
     equity = np.cumprod(1 + returns)
 
-    peak = np.maximum.accumulate(
+    peaks = np.maximum.accumulate(
         np.insert(equity, 0, 1)
     )[1:]
 
-    drawdowns = 1 - equity / peak
-
-    max_drawdown = (
-        float(np.max(drawdowns))
-        if len(drawdowns) else 0.0
-    )
+    dd = 1 - equity / peaks
 
     return {
         "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
+        "win_rate": len(wins) / len(trades),
+        "profit_factor": float(min(pf, 5)),
+        "net_return": float(equity[-1] - 1),
+        "max_drawdown": float(dd.max())
     }
 
 
@@ -804,52 +815,49 @@ def calculate_metrics(trades):
 # WALK-FORWARD
 # ============================================================
 
-def walk_forward_validation(
-    X,
-    y,
+def walk_forward(
     dataset,
     raw,
     horizon,
-    C,
     threshold,
     stop_multiplier,
     fee_rate,
-    slippage_bps
+    slippage_bps,
+    sprt_window
 ):
 
+    from sklearn.model_selection import TimeSeriesSplit
+
     splitter = TimeSeriesSplit(
         n_splits=3,
         gap=horizon
     )
 
-    all_predictions = []
-    all_targets = []
     all_trades = []
-
-    fold_reports = []
+    reports = []
 
     for fold, (train_idx, val_idx) in enumerate(
-        splitter.split(X),
+        splitter.split(dataset),
         start=1
     ):
 
-        model = create_model(C)
+        train_df = dataset.iloc[
+            train_idx
+        ].reset_index(drop=True)
 
-        model.fit(
-            X.iloc[train_idx],
-            y.iloc[train_idx]
-        )
+        val_df = dataset.iloc[
+            val_idx
+        ].reset_index(drop=True)
 
-        probabilities = get_probability(
-            model,
-            X.iloc[val_idx]
-        )
+        train_y = train_df["target"].values.astype(int)
 
-        targets = y.iloc[val_idx].values
+        result = fit_predict_regimes(
+            train_df,
+            train_y,
+            val_df
+        )
 
-        predictions = (
-            probabilities >= 0.5
-        ).astype(int)
+        probabilities = result["probabilities"]
 
         trades = simulate_trades(
             raw,
@@ -860,49 +868,27 @@ def walk_forward_validation(
             stop_multiplier,
             horizon,
             fee_rate,
-            slippage_bps
+            slippage_bps,
+            sprt_window
         )
 
         metrics = calculate_metrics(trades)
 
-        all_predictions.extend(
-            predictions.tolist()
-        )
-
-        all_targets.extend(
-            targets.tolist()
-        )
-
         all_trades.extend(trades)
 
-        fold_reports.append({
+        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
+    return calculate_metrics(all_trades), reports
 
 
 # ============================================================
 # OPTUNA
 # ============================================================
 
-def optimize_model(
-    X,
-    y,
+def optimize(
     dataset,
     raw,
     horizon,
@@ -911,6 +897,8 @@ def optimize_model(
     trials
 ):
 
+    from sklearn.model_selection import TimeSeriesSplit
+
     splitter = TimeSeriesSplit(
         n_splits=3,
         gap=horizon
@@ -918,17 +906,10 @@ def optimize_model(
 
     def objective(trial):
 
-        C = trial.suggest_float(
-            "C",
-            0.01,
-            30.0,
-            log=True
-        )
-
         threshold = trial.suggest_float(
             "threshold",
-            0.52,
-            0.75
+            0.55,
+            0.80
         )
 
         stop_multiplier = trial.suggest_float(
@@ -937,50 +918,58 @@ def optimize_model(
             2.5
         )
 
-        fold_scores = []
+        sprt_window = trial.suggest_categorical(
+            "sprt_window",
+            [12, 18, 24, 36, 48]
+        )
 
-        for train_idx, val_idx in splitter.split(X):
+        scores = []
 
-            model = create_model(C)
+        for train_idx, val_idx in splitter.split(dataset):
 
-            model.fit(
-                X.iloc[train_idx],
-                y.iloc[train_idx]
-            )
+            train_df = dataset.iloc[
+                train_idx
+            ].reset_index(drop=True)
+
+            val_df = dataset.iloc[
+                val_idx
+            ].reset_index(drop=True)
 
-            probabilities = get_probability(
-                model,
-                X.iloc[val_idx]
+            train_y = train_df["target"].values.astype(int)
+
+            result = fit_predict_regimes(
+                train_df,
+                train_y,
+                val_df
             )
 
             trades = simulate_trades(
                 raw,
                 dataset,
                 val_idx,
-                probabilities,
+                result["probabilities"],
                 threshold,
                 stop_multiplier,
                 horizon,
                 fee_rate,
-                slippage_bps
+                slippage_bps,
+                sprt_window
             )
 
             metrics = calculate_metrics(trades)
 
-            # Aşırı az işlem yapan modelleri cezalandır.
             score = (
                 metrics["net_return"] * 100
                 + min(metrics["profit_factor"], 3) * 1.5
                 - metrics["max_drawdown"] * 40
-                + min(metrics["trades"], 20) * 0.05
             )
 
             if metrics["trades"] < 3:
                 score -= 5
 
-            fold_scores.append(score)
+            scores.append(score)
 
-        return float(np.mean(fold_scores))
+        return float(np.mean(scores))
 
     study = optuna.create_study(
         direction="maximize",
@@ -999,222 +988,224 @@ def optimize_model(
 
 
 # ============================================================
-# HOLDOUT TEST
+# HOLDOUT
 # ============================================================
 
-def independent_holdout(
-    X,
-    y,
+def holdout_test(
     dataset,
     raw,
     horizon,
-    C,
     threshold,
     stop_multiplier,
     fee_rate,
-    slippage_bps
+    slippage_bps,
+    sprt_window
 ):
 
-    n = len(X)
+    n = len(dataset)
 
     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)
+    train_df = dataset.iloc[
+        :train_end
+    ].reset_index(drop=True)
 
-    test_idx = np.arange(split, n)
+    test_df = dataset.iloc[
+        split:
+    ].reset_index(drop=True)
 
-    model = create_model(C)
+    train_y = train_df["target"].values.astype(int)
 
-    model.fit(
-        X.iloc[train_idx],
-        y.iloc[train_idx]
+    result = fit_predict_regimes(
+        train_df,
+        train_y,
+        test_df
     )
 
-    probabilities = get_probability(
-        model,
-        X.iloc[test_idx]
+    test_indices = np.arange(
+        split,
+        n
     )
 
-    targets = y.iloc[test_idx].values
-
-    predictions = (
-        probabilities >= 0.5
-    ).astype(int)
-
     trades = simulate_trades(
         raw,
         dataset,
-        test_idx,
-        probabilities,
+        test_indices,
+        result["probabilities"],
         threshold,
         stop_multiplier,
         horizon,
         fee_rate,
-        slippage_bps
+        slippage_bps,
+        sprt_window
     )
 
     metrics = calculate_metrics(trades)
 
-    metrics["accuracy"] = accuracy_score(
-        targets,
-        predictions
-    )
-
-    metrics["balanced_accuracy"] = (
-        balanced_accuracy_score(
-            targets,
-            predictions
-        )
-    )
-
-    metrics["brier"] = brier_score_loss(
-        targets,
-        probabilities
-    )
-
-    return metrics, model, probabilities
+    return metrics, result
 
 
 # ============================================================
-# OVERFIT RISK INDICATOR
+# OVERFIT INDICATOR
 # ============================================================
 
-def calculate_overfit_risk(
-    wf_metrics,
-    holdout_metrics
-):
-
-    wf_ba = wf_metrics["balanced_accuracy"]
-
-    holdout_ba = holdout_metrics["balanced_accuracy"]
+def overfit_indicator(wf, holdout):
 
-    wf_pf = wf_metrics["profit_factor"]
+    # Heuristic generalization-gap indicator.
+    # Not a statistically calibrated probability.
 
-    holdout_pf = holdout_metrics["profit_factor"]
-
-    accuracy_gap = max(
+    gap = max(
         0,
-        wf_ba - holdout_ba
+        wf["win_rate"] - holdout["win_rate"]
     )
 
     pf_gap = max(
         0,
-        wf_pf - holdout_pf
+        wf["profit_factor"] - holdout["profit_factor"]
     )
 
-    risk = max(
-        accuracy_gap * 500,
+    score = max(
+        gap * 150,
         pf_gap * 15
     )
 
-    risk = float(
-        np.clip(risk, 0, 100)
+    score = float(
+        np.clip(score, 0, 100)
     )
 
-    if risk < 15:
-
+    if score < 15:
         label = "DÜŞÜK"
 
-    elif risk < 35:
-
+    elif score < 35:
         label = "ORTA"
 
-    elif risk < 60:
-
+    elif score < 60:
         label = "YÜKSEK"
 
     else:
-
         label = "ÇOK YÜKSEK"
 
-    return risk, label
+    return score, label
 
 
 # ============================================================
-# LIVE SIGNAL
+# LIVE PREDICTION
 # ============================================================
 
-def generate_live_signal(
-    model,
-    latest,
-    threshold,
+def live_prediction(
+    dataset,
+    raw,
     horizon,
-    stop_multiplier
+    params
 ):
 
-    X_live = latest[FEATURE_COLUMNS].astype(float)
+    train_y = dataset["target"].values.astype(int)
+
+    latest = dataset.tail(1).reset_index(drop=True)
 
-    probability_long = float(
-        get_probability(model, X_live)[0]
+    # Final model: all currently labeled data.
+    result = fit_predict_regimes(
+        dataset,
+        train_y,
+        latest
     )
 
-    probability_short = 1 - probability_long
+    long_probability = float(
+        result["probabilities"][-1]
+    )
 
-    price = float(latest.iloc[0]["close"])
+    short_probability = 1 - long_probability
 
-    volatility = float(
-        latest.iloc[0]["rv_24"]
-    )
+    hmm_posterior = result["future_posterior"][-1]
 
-    risk_pct = (
-        volatility *
-        np.sqrt(horizon) *
-        stop_multiplier
-    )
+    threshold = params["threshold"]
+
+    stop_multiplier = params["stop_multiplier"]
+
+    sprt_window = params["sprt_window"]
 
-    risk_pct = float(
-        np.clip(risk_pct, 0.002, 0.05)
+    raw_i = int(
+        latest.iloc[0]["raw_i"]
     )
 
-    risk_distance = price * risk_pct
+    sprt_decision, long_llr, short_llr = sprt_test(
+        raw,
+        raw_i,
+        window=sprt_window
+    )
 
-    if probability_long >= threshold:
+    if (
+        long_probability >= threshold
+        and sprt_decision == "LONG"
+    ):
 
         signal = "LONG"
 
-        stop = price - risk_distance
+    elif (
+        short_probability >= threshold
+        and sprt_decision == "SHORT"
+    ):
 
-        target = price + 2 * risk_distance
+        signal = "SHORT"
 
-    elif probability_short >= threshold:
+    else:
 
-        signal = "SHORT"
+        signal = "NO TRADE"
 
-        stop = price + risk_distance
+    price = float(
+        latest.iloc[0]["close"]
+    )
 
-        target = price - 2 * risk_distance
+    volatility = float(
+        latest.iloc[0]["realized_volatility"]
+    )
 
-    else:
+    risk_pct = np.clip(
+        volatility * np.sqrt(horizon) * stop_multiplier,
+        0.002,
+        0.05
+    )
 
-        signal = "NO TRADE"
+    distance = price * risk_pct
 
-        stop = None
+    if signal == "LONG":
+
+        stop = price - distance
+        target = price + 2 * distance
 
+    elif signal == "SHORT":
+
+        stop = price + distance
+        target = price - 2 * distance
+
+    else:
+
+        stop = None
         target = None
 
     return {
         "signal": signal,
-        "long": probability_long,
-        "short": probability_short,
+        "long": long_probability,
+        "short": short_probability,
         "price": price,
         "stop": stop,
         "target": target,
-        "risk_pct": risk_pct
+        "risk_pct": risk_pct,
+        "regimes": hmm_posterior,
+        "sprt": sprt_decision,
+        "long_llr": long_llr,
+        "short_llr": short_llr,
+        "regime_bayes": result["regime_probabilities"]
     }
 
 
 # ============================================================
-# MAIN APPLICATION
+# MAIN
 # ============================================================
 
-def run_quant(
+def run_app(
     candle_count,
     horizon,
     trials,
@@ -1230,59 +1221,29 @@ def run_quant(
 
         fee_rate = fee_percent / 100
 
-        # ----------------------------------------------------
-        # FETCH
-        # ----------------------------------------------------
-
         raw = fetch_data(
             int(candle_count)
         )
 
-        # ----------------------------------------------------
-        # FEATURES
-        # ----------------------------------------------------
-
-        X, y, dataset, live_features = prepare_dataset(
+        dataset, live = prepare_dataset(
             raw,
             int(horizon)
         )
 
-        # raw_i değerleri orijinal mum pozisyonlarıdır.
-        # Backtest bu indeksleri kullanır.
-
-        # ----------------------------------------------------
-        # DEVELOPMENT / HOLDOUT SEPARATION
-        # ----------------------------------------------------
-
-        split = int(len(X) * 0.80)
-
-        development_end = split - int(horizon)
+        split = int(len(dataset) * 0.80)
 
-        X_dev = X.iloc[:development_end].reset_index(
-            drop=True
-        )
-
-        y_dev = y.iloc[:development_end].reset_index(
-            drop=True
-        )
-
-        dev_dataset = dataset.iloc[
-            :development_end
+        development = dataset.iloc[
+            :split - int(horizon)
         ].reset_index(drop=True)
 
-        if len(X_dev) < 500:
+        if len(development) < 300:
             raise ValueError(
-                "Optimizasyon için geliştirme verisi yetersiz."
+                "Optimizasyon için veri yetersiz."
             )
 
-        # ----------------------------------------------------
-        # OPTUNA
-        # ----------------------------------------------------
-
-        best_params, best_score = optimize_model(
-            X_dev,
-            y_dev,
-            dev_dataset,
+        # 1. OPTUNA
+        best_params, best_score = optimize(
+            development,
             raw,
             int(horizon),
             fee_rate,
@@ -1290,193 +1251,157 @@ def run_quant(
             int(trials)
         )
 
-        C = best_params["C"]
-
-        threshold = best_params["threshold"]
-
-        stop_multiplier = best_params["stop_multiplier"]
-
-        # ----------------------------------------------------
-        # WALK FORWARD
-        # ----------------------------------------------------
-
-        wf_metrics, fold_reports = walk_forward_validation(
-            X_dev,
-            y_dev,
-            dev_dataset,
+        # 2. WALK FORWARD
+        wf, fold_reports = walk_forward(
+            development,
             raw,
             int(horizon),
-            C,
-            threshold,
-            stop_multiplier,
+            best_params["threshold"],
+            best_params["stop_multiplier"],
             fee_rate,
-            float(slippage_bps)
+            float(slippage_bps),
+            best_params["sprt_window"]
         )
 
-        # ----------------------------------------------------
-        # 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)
-            )
+        # 3. INDEPENDENT HOLDOUT
+        holdout, holdout_result = holdout_test(
+            dataset,
+            raw,
+            int(horizon),
+            best_params["threshold"],
+            best_params["stop_multiplier"],
+            fee_rate,
+            float(slippage_bps),
+            best_params["sprt_window"]
         )
 
-        # ----------------------------------------------------
-        # OVERFIT RISK
-        # ----------------------------------------------------
-
-        overfit_score, overfit_label = (
-            calculate_overfit_risk(
-                wf_metrics,
-                holdout_metrics
-            )
+        # 4. OVERFIT
+        overfit_score, overfit_label = overfit_indicator(
+            wf,
+            holdout
         )
 
-        # ----------------------------------------------------
-        # FINAL LIVE MODEL
-        # ----------------------------------------------------
-
-        final_model = create_model(C)
-
-        final_model.fit(
-            X,
-            y
-        )
-
-        latest = live_features.tail(1)
-
-        signal = generate_live_signal(
-            final_model,
-            latest,
-            threshold,
+        # 5. LIVE
+        live_result = live_prediction(
+            dataset,
+            raw,
             int(horizon),
-            stop_multiplier
+            best_params
         )
 
-        # ----------------------------------------------------
-        # REPORT
-        # ----------------------------------------------------
-
         last_time = pd.to_datetime(
-            latest.iloc[0]["timestamp"],
+            int(raw.iloc[-1]["timestamp"]),
             unit="ms",
             utc=True
         )
 
+        regimes = live_result["regimes"]
+
+        bayes = live_result["regime_bayes"]
+
         report = f"""
-# BTC/USDT QUANT ENGINE
+# OKX BTC/USDT QUANT ENGINE
 
-<badge color="success">OKX CONNECTED</badge>
+<badge color="success">HMM + BAYESIAN + SPRT</badge>
 
-## 1. Veri
+## Veri
 
 | 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} |
+| Ham mum | {len(raw)} |
+| Temiz örnek | {len(dataset)} |
+| Geliştirme örneği | {len(development)} |
+| Holdout örneği | {len(dataset)-split} |
 | Zaman dilimi | 1H |
-| Tahmin ufku | {horizon} saat |
 | Son tamamlanmış mum | {last_time} |
 
-## 2. Canlı tahmin
+## Canlı sinyal
 
-# {signal['signal']}
+# {live_result['signal']}
 
 | Metrik | Sonuç |
 |---|---:|
-| 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"} |
+| BTC fiyatı | {live_result['price']:,.2f} USDT |
+| LONG olasılığı | %{live_result['long']*100:.2f} |
+| SHORT olasılığı | %{live_result['short']*100:.2f} |
+| SPRT kararı | {live_result['sprt']} |
+| LONG LLR | {live_result['long_llr']:.3f} |
+| SHORT LLR | {live_result['short_llr']:.3f} |
+| Risk mesafesi | %{live_result['risk_pct']*100:.3f} |
+| Stop-loss | {f"{live_result['stop']:,.2f}" if live_result['stop'] else "Yok"} |
+| 2R hedef | {f"{live_result['target']:,.2f}" if live_result['target'] else "Yok"} |
+
+## HMM gizli rejimleri
+
+| Rejim | Olasılık |
+|---|---:|
+| Bearish | %{regimes[0]*100:.2f} |
+| Neutral | %{regimes[1]*100:.2f} |
+| Bullish | %{regimes[2]*100:.2f} |
 
-## 3. Walk-forward sonuçları
+## Bayesian rejim olasılıkları
 
-| Metrik | Sonuç |
+| Rejim | LONG olasılığı |
 |---|---:|
-| 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']} |
+| Bearish | %{bayes[0]*100:.2f} |
+| Neutral | %{bayes[1]*100:.2f} |
+| Bullish | %{bayes[2]*100:.2f} |
 
-## 4. Bağımsız holdout backtest
+## Walk-forward backtest
 
 | Metrik | Sonuç |
 |---|---:|
-| 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']} |
+| İşlem sayısı | {wf['trades']} |
+| Win rate | %{wf['win_rate']*100:.2f} |
+| Profit Factor | {wf['profit_factor']:.2f} |
+| Net getiri | %{wf['net_return']*100:.2f} |
+| Max drawdown | %{wf['max_drawdown']*100:.2f} |
 
-## 5. Overfit analizi
+## Bağımsız holdout
 
-# {overfit_label}
+| Metrik | Sonuç |
+|---|---:|
+| İşlem sayısı | {holdout['trades']} |
+| Win rate | %{holdout['win_rate']*100:.2f} |
+| Profit Factor | {holdout['profit_factor']:.2f} |
+| Net getiri | %{holdout['net_return']*100:.2f} |
+| Max drawdown | %{holdout['max_drawdown']*100:.2f} |
 
-**Overfit risk puanı: {overfit_score:.1f}/100**
+## Overfit göstergesi
 
-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.
+**{overfit_label} — {overfit_score:.1f}/100**
 
-## 6. Optuna parametreleri
+Bu puan walk-forward ve holdout sonuçları arasındaki farkı gösteren sezgisel bir göstergedir; overfit olasılığı değildir.
+
+## Optuna parametreleri
 
 | Parametre | Değer |
 |---|---:|
-| 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} |
+| Probability threshold | {best_params['threshold']:.4f} |
+| Stop multiplier | {best_params['stop_multiplier']:.4f} |
+| SPRT window | {best_params['sprt_window']} |
+| Optuna score | {best_score:.4f} |
 
-## 7. Walk-forward fold sonuçları
+## Walk-forward fold detayları
 
-| Fold | Balanced Acc. | Win Rate | PF | Net Getiri | İşlem |
-|---|---:|---:|---:|---:|---:|
+| Fold | İşlem | Win rate | PF | Getiri |
+|---|---:|---:|---:|---:|
 """
 
         for f in fold_reports:
 
             report += (
                 f"| {f['fold']} "
-                f"| %{f['balanced_accuracy'] * 100:.2f} "
-                f"| %{f['win_rate'] * 100:.2f} "
+                f"| {f['trades']} "
+                f"| %{f['win_rate']*100:.2f} "
                 f"| {f['profit_factor']:.2f} "
-                f"| %{f['net_return'] * 100:.2f} "
-                f"| {f['trades']} |\\n"
+                f"| %{f['net_return']*100:.2f} |\n"
             )
 
         report += """
-
 ---
 
-### Model hakkında
-
-- 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.
+**Önemli:** Backtest; funding, gerçek emir defteri derinliği, likidasyon ve gerçek emir kaymasını eksiksiz modellemez. Sonuçlar gelecekteki performansı garanti etmez.
 """
 
         return report
@@ -1484,85 +1409,84 @@ Bu puan walk-forward ve holdout sonuçları arasındaki farktan üretilen sezgis
     except Exception as e:
 
         return (
-            "# UYGULAMA HATASI\n\n"
-            f"`{type(e).__name__}: {str(e)}`\n\n"
-            "OKX bağlantısını, veri sayısını ve parametreleri kontrol et."
+            "# HATA\n\n"
+            f"`{type(e).__name__}: {str(e)}`"
         )
 
 
 # ============================================================
-# GRADIO UI
+# GRADIO
 # ============================================================
 
 with gr.Blocks(
-    title="OKX BTC Quant Engine",
+    title="OKX Bayesian HMM Quant",
     theme=gr.themes.Soft()
 ) as demo:
 
     gr.Markdown(
         """
-# BTC/USDT Quant Engine
+# BTC/USDT Bayesian Regime Engine
 
-**Pure Mathematics · OKX Swap · 1 Hour**
+**HMM + Bayesian Regime Switching + SPRT**
 
-RSI, MACD, EMA, VWAP veya Supertrend yok.
-Sadece matematiksel fiyat ve hacim analizi.
+Klasik teknik indikatör yok.
+Yalnızca matematiksel ve olasılıksal modelleme.
 """
     )
 
     with gr.Row():
 
         candle_count = gr.Slider(
-            minimum=1000,
-            maximum=5000,
+            1000,
+            5000,
             value=3000,
             step=500,
-            label="OKX Mum Sayısı"
+            label="OKX mum sayısı"
         )
 
         horizon = gr.Slider(
-            minimum=2,
-            maximum=24,
+            2,
+            24,
             value=6,
             step=1,
-            label="Tahmin Ufku (Saat)"
+            label="Tahmin ufku (saat)"
         )
 
     with gr.Row():
 
         trials = gr.Slider(
-            minimum=5,
-            maximum=50,
+            5,
+            50,
             value=15,
             step=5,
-            label="Optuna Deneme Sayısı"
+            label="Optuna denemesi"
         )
 
         fee_percent = gr.Slider(
-            minimum=0,
-            maximum=0.20,
+            0,
+            0.20,
             value=0.05,
             step=0.01,
-            label="Komisyon (%) / Taraf"
+            label="Komisyon % / taraf"
         )
 
         slippage_bps = gr.Slider(
-            minimum=0,
-            maximum=20,
+            0,
+            20,
             value=2,
             step=1,
-            label="Kayma (baz puan) / Taraf"
+            label="Kayma baz puan / taraf"
         )
 
     run_button = gr.Button(
-        "QUANT ANALİZİ BAŞLAT",
+        "BAYESIAN QUANT ANALİZİ BAŞLAT",
         variant="primary"
     )
 
     output = gr.Markdown()
 
     run_button.click(
-        fn=run_quant,
+        fn=run_app,
         inputs=[
             candle_count,
             horizon,