Update app.py

app.py

@@ -10,6 +10,7 @@ import gradio as gr
 import optuna
 
 from hmmlearn.hmm import GaussianHMM
+from sklearn.preprocessing import StandardScaler
 
 
 # ============================================================
@@ -20,12 +21,25 @@ SYMBOL = "BTC/USDT:USDT"
 TIMEFRAME = "1h"
 TIMEFRAME_MS = 60 * 60 * 1000
 
-HMM_COLUMNS = [
+MACRO_FEATURES = [
     "log_return",
     "realized_volatility",
     "range_return"
 ]
 
+MICRO_FEATURES = [
+    "return_zscore",
+    "autocorrelation",
+    "volume_zscore"
+]
+
+N_MACRO = 3
+N_MICRO = 2
+N_JOINT = N_MACRO * N_MICRO
+
+MIN_TRAIN_ROWS = 300
+MIN_RELIABLE_TRADES = 30
+
 
 # ============================================================
 # OKX DATA
@@ -44,16 +58,19 @@ def fetch_data(candle_count):
     exchange.load_markets()
 
     if SYMBOL not in exchange.markets:
-        raise ValueError(f"{SYMBOL} OKX piyasasında bulunamadı.")
+        raise ValueError(
+            f"{SYMBOL} OKX piyasasında bulunamadı."
+        )
 
     now = exchange.milliseconds()
 
-    since = now - (candle_count + 20) * TIMEFRAME_MS
+    cursor = now - (
+        int(candle_count) + 30
+    ) * TIMEFRAME_MS
 
     candles = []
-    cursor = since
 
-    for _ in range(int(candle_count / 100) + 20):
+    for _ in range(60):
 
         batch = exchange.fetch_ohlcv(
             SYMBOL,
@@ -69,7 +86,7 @@ def fetch_data(candle_count):
 
         last_timestamp = batch[-1][0]
 
-        if last_timestamp <= cursor:
+        if last_timestamp < cursor:
             break
 
         cursor = last_timestamp + TIMEFRAME_MS
@@ -80,7 +97,9 @@ def fetch_data(candle_count):
         if last_timestamp >= now - TIMEFRAME_MS:
             break
 
-        time.sleep(exchange.rateLimit / 1000)
+        time.sleep(
+            exchange.rateLimit / 1000
+        )
 
     if not candles:
         raise ValueError("OKX veri döndürmedi.")
@@ -97,40 +116,54 @@ def fetch_data(candle_count):
         ]
     )
 
-    df = df.drop_duplicates("timestamp")
-    df = df.sort_values("timestamp")
+    df = (
+        df.drop_duplicates("timestamp")
+        .sort_values("timestamp")
+        .reset_index(drop=True)
+    )
 
     now = exchange.milliseconds()
 
-    # Yalnızca tamamlanmış mumlar
+    # Yalnızca kapanmış 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")
+    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 = df.dropna().reset_index(drop=True)
+    df = df.replace(
+        [np.inf, -np.inf],
+        np.nan
+    ).dropna()
 
     df = df[
         (df["close"] > 0) &
-        (df["high"] >= df["low"])
-    ].reset_index(drop=True)
+        (df["high"] >= df["low"]) &
+        (df["low"] > 0)
+    ]
+
+    df = df.tail(
+        int(candle_count)
+    ).reset_index(drop=True)
 
     if len(df) < 500:
         raise ValueError(
-            f"Yeterli mum yok. Gelen: {len(df)}"
+            f"Yeterli veri yok: {len(df)} mum."
         )
 
+    df["raw_i"] = np.arange(len(df))
+
     return df
 
 
 # ============================================================
-# MATHEMATICAL FEATURES
-# No RSI / MACD / EMA / VWAP
+# CAUSAL MATHEMATICAL FEATURES
 # ============================================================
 
 def create_features(raw):
@@ -141,9 +174,9 @@ def create_features(raw):
 
     returns = log_close.diff()
 
+    # Macro layer
     df["log_return"] = returns
 
-    # HMM observations
     df["realized_volatility"] = (
         returns.rolling(24).std()
     )
@@ -152,33 +185,14 @@ def create_features(raw):
         df["high"] / df["low"]
     )
 
-    # Bayesian analysis auxiliary statistics
-    df["return_6"] = (
-        log_close - log_close.shift(6)
-    )
-
-    df["return_24"] = (
-        log_close - log_close.shift(24)
-    )
-
-    df["volatility_48"] = (
-        returns.rolling(48).std()
-    )
+    # Micro layer
+    rolling_mean = returns.rolling(48).mean()
 
-    df["volume_change"] = np.log1p(
-        df["volume"]
-    ).diff()
+    rolling_std = returns.rolling(48).std()
 
-    df["volume_volatility"] = (
-        df["volume_change"].rolling(24).std()
-    )
-
-    df["return_skew"] = (
-        returns.rolling(48).skew()
-    )
-
-    df["return_kurtosis"] = (
-        returns.rolling(48).kurt()
+    df["return_zscore"] = (
+        (returns - rolling_mean) /
+        rolling_std.replace(0, np.nan)
     )
 
     df["autocorrelation"] = (
@@ -187,18 +201,26 @@ def create_features(raw):
         )
     )
 
-    df["price_zscore"] = (
-        (log_close - log_close.rolling(48).mean())
-        / log_close.rolling(48).std()
+    log_volume = np.log1p(
+        df["volume"].clip(lower=0)
     )
 
-    df["raw_i"] = np.arange(len(df))
+    volume_mean = log_volume.rolling(48).mean()
+
+    volume_std = log_volume.rolling(48).std()
 
-    return df.replace(
+    df["volume_zscore"] = (
+        (log_volume - volume_mean) /
+        volume_std.replace(0, np.nan)
+    )
+
+    df = df.replace(
         [np.inf, -np.inf],
         np.nan
     )
 
+    return df
+
 
 # ============================================================
 # DATASET
@@ -208,397 +230,531 @@ def prepare_dataset(raw, horizon):
 
     df = create_features(raw)
 
-    future_close = df["close"].shift(-horizon)
-
-    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"
-        ]
+        MACRO_FEATURES +
+        MICRO_FEATURES
     )
 
     live = df.dropna(
         subset=required
     ).copy()
 
+    future_close = live["close"].shift(
+        -int(horizon)
+    )
+
+    live["target"] = np.where(
+        future_close.notna(),
+        (
+            future_close > live["close"]
+        ).astype(float),
+        np.nan
+    )
+
     dataset = live.dropna(
         subset=["target"]
     ).copy()
 
-    live = live.reset_index(drop=True)
     dataset = dataset.reset_index(drop=True)
 
-    if len(dataset) < 500:
+    live = live.reset_index(drop=True)
+
+    if len(dataset) < MIN_TRAIN_ROWS:
         raise ValueError(
-            f"Temiz veri yetersiz: {len(dataset)}"
+            f"Yeterli eğitim verisi yok: {len(dataset)}"
         )
 
     return dataset, live
 
 
 # ============================================================
-# HMM SCALER
+# GAUSSIAN HMM FORWARD FILTER
 # ============================================================
 
-class HMMRegime:
+def forward_filter(
+    model,
+    X_scaled,
+    initial_alpha=None
+):
 
-    def __init__(self):
+    means = model.means_
+
+    covars = np.asarray(
+        model.covars_
+    )
+
+    if covars.ndim == 3:
+
+        variances = np.diagonal(
+            covars,
+            axis1=1,
+            axis2=2
+        )
 
-        self.mean = None
-        self.std = None
-        self.model = None
-        self.order = None
+    else:
+
+        variances = covars
+
+    variances = np.maximum(
+        variances,
+        1e-8
+    )
 
-    def scale_fit(self, X):
+    n_states = model.n_components
+
+    n_features = X_scaled.shape[1]
+
+    log_emissions = np.zeros(
+        (len(X_scaled), n_states)
+    )
 
-        self.mean = np.mean(X, axis=0)
+    # Gaussian emission likelihood
+    for state in range(n_states):
 
-        self.std = np.std(X, axis=0)
+        diff = (
+            X_scaled - means[state]
+        )
 
-        self.std = np.where(
-            self.std < 1e-10,
-            1.0,
-            self.std
+        log_emissions[:, state] = -0.5 * (
+            n_features * np.log(2 * np.pi)
+            + np.sum(
+                np.log(variances[state])
+            )
+            + np.sum(
+                diff ** 2 / variances[state],
+                axis=1
+            )
         )
 
-        return (X - self.mean) / self.std
+    transition = model.transmat_
 
-    def scale_transform(self, X):
+    if initial_alpha is None:
 
-        return (X - self.mean) / self.std
+        alpha = model.startprob_.copy()
 
-    def fit(self, train_df):
+        first_observation = 0
+
+    else:
+
+        alpha = np.asarray(
+            initial_alpha,
+            dtype=float
+        ).copy()
 
-        X = train_df[HMM_COLUMNS].values.astype(float)
+        first_observation = 0
 
-        X_scaled = self.scale_fit(X)
+    posterior = []
+
+    for i in range(len(X_scaled)):
+
+        if i > 0 or initial_alpha is not None:
+
+            alpha = alpha @ transition
+
+        log_alpha = (
+            np.log(
+                np.maximum(alpha, 1e-300)
+            )
+            + log_emissions[i]
+        )
+
+        log_alpha -= np.max(log_alpha)
+
+        alpha = np.exp(log_alpha)
+
+        total = alpha.sum()
+
+        if (
+            total <= 0
+            or not np.isfinite(total)
+        ):
+
+            alpha = (
+                np.ones(n_states) / n_states
+            )
+
+        else:
+
+            alpha /= total
+
+        posterior.append(
+            alpha.copy()
+        )
+
+    posterior = np.asarray(posterior)
+
+    return posterior, alpha.copy()
+
+
+# ============================================================
+# HMM LAYER
+# ============================================================
+
+class HMMLayer:
+
+    def __init__(
+        self,
+        n_states,
+        random_state=42
+    ):
+
+        self.n_states = n_states
+
+        self.scaler = StandardScaler()
 
         self.model = GaussianHMM(
-            n_components=3,
+            n_components=n_states,
             covariance_type="diag",
             n_iter=150,
             tol=0.001,
             min_covar=1e-4,
-            random_state=42
+            random_state=random_state
         )
 
-        self.model.fit(X_scaled)
+        self.fitted = False
 
-        # 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]
-        )
-
-        return self
+    def fit(self, X):
 
-    def filter(self, df, initial_alpha=None):
+        X = np.asarray(
+            X,
+            dtype=float
+        )
 
-        X = df[HMM_COLUMNS].values.astype(float)
+        X_scaled = self.scaler.fit_transform(
+            X
+        )
 
-        X_scaled = self.scale_transform(X)
+        self.model.fit(X_scaled)
 
-        model = self.model
+        self.fitted = True
 
-        means = model.means_
+        return self
 
-        covars = np.asarray(model.covars_)
+    def filter(
+        self,
+        X,
+        initial_alpha=None
+    ):
 
-        if covars.ndim == 3:
-            variances = np.diagonal(
-                covars,
-                axis1=1,
-                axis2=2
+        if not self.fitted:
+            raise RuntimeError(
+                "HMM katmanı eğitilmedi."
             )
-        else:
-            variances = covars
 
-        variances = np.maximum(
-            variances,
-            1e-8
+        X = np.asarray(
+            X,
+            dtype=float
         )
 
-        n_components = model.n_components
-
-        dimension = X_scaled.shape[1]
+        X_scaled = self.scaler.transform(
+            X
+        )
 
-        # Gaussian emission log likelihood
-        log_emissions = np.zeros(
-            (len(X_scaled), n_components)
+        return forward_filter(
+            self.model,
+            X_scaled,
+            initial_alpha
         )
 
-        for state in range(n_components):
 
-            diff = X_scaled - means[state]
+# ============================================================
+# HIERARCHICAL HMM
+# ============================================================
 
-            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
-                )
-            )
+class HierarchicalHMM:
 
-        # Numerically stable forward filtering
-        posterior = []
+    def __init__(self):
 
-        if initial_alpha is None:
+        self.macro = HMMLayer(
+            N_MACRO,
+            random_state=42
+        )
 
-            alpha = model.startprob_.copy()
+        self.micro = HMMLayer(
+            N_MICRO,
+            random_state=73
+        )
 
-        else:
+        self.compatibility = None
 
-            alpha = np.asarray(
-                initial_alpha,
-                dtype=float
-            ).copy()
+    def fit(self, train_df):
 
-        transition = model.transmat_
+        macro_X = train_df[
+            MACRO_FEATURES
+        ].values
 
-        for i in range(len(X_scaled)):
+        micro_X = train_df[
+            MICRO_FEATURES
+        ].values
 
-            if i > 0 or initial_alpha is not None:
+        self.macro.fit(macro_X)
 
-                alpha = alpha @ transition
+        self.micro.fit(micro_X)
 
-            log_alpha = (
-                np.log(np.maximum(alpha, 1e-300))
-                + log_emissions[i]
-            )
+        macro_post, self.last_macro = (
+            self.macro.filter(macro_X)
+        )
 
-            log_alpha -= np.max(log_alpha)
+        micro_post, self.last_micro = (
+            self.micro.filter(micro_X)
+        )
 
-            alpha = np.exp(log_alpha)
+        # Macro-micro compatibility matrix.
+        # Estimated only from training observations.
+        compatibility = np.zeros(
+            (N_MACRO, N_MICRO)
+        )
 
-            total = alpha.sum()
+        for m in range(N_MACRO):
 
-            if total <= 0 or not np.isfinite(total):
+            for u in range(N_MICRO):
 
-                alpha = np.ones(n_components) / n_components
+                compatibility[m, u] = (
+                    np.sum(
+                        macro_post[:, m]
+                        * micro_post[:, u]
+                    )
+                    + 0.5
+                )
 
-            else:
+        compatibility /= (
+            compatibility.sum(
+                axis=1,
+                keepdims=True
+            )
+        )
 
-                alpha /= total
+        self.compatibility = compatibility
 
-            posterior.append(alpha.copy())
+        train_joint = self.combine(
+            macro_post,
+            micro_post
+        )
 
-        posterior = np.asarray(posterior)
+        return train_joint
 
-        # Stable column order: Bearish, Neutral, Bullish
-        posterior = posterior[:, self.order]
+    def combine(
+        self,
+        macro_post,
+        micro_post
+    ):
 
-        last_alpha = (
-            posterior[-1].copy()
-            if len(posterior)
-            else None
+        joint = np.zeros(
+            (
+                len(macro_post),
+                N_MACRO,
+                N_MICRO
+            )
         )
 
-        return posterior, last_alpha
+        for m in range(N_MACRO):
 
+            weighted_micro = (
+                micro_post *
+                self.compatibility[m]
+            )
 
-# ============================================================
-# BAYESIAN REGIME SWITCHING
-# ============================================================
+            denominator = (
+                weighted_micro.sum(
+                    axis=1,
+                    keepdims=True
+                )
+            )
 
-def bayesian_regime_probability(
-    train_posterior,
-    train_targets,
-    future_posterior,
-    prior_alpha=2.0,
-    prior_beta=2.0
-):
+            conditional_micro = (
+                weighted_micro /
+                np.maximum(
+                    denominator,
+                    1e-12
+                )
+            )
 
-    # State order:
-    # 0 Bearish, 1 Neutral, 2 Bullish
+            joint[:, m, :] = (
+                macro_post[:, m, None]
+                * conditional_micro
+            )
 
-    regime_probabilities = []
+        joint = joint.reshape(
+            len(joint),
+            N_JOINT
+        )
 
-    for state in range(3):
+        joint /= np.maximum(
+            joint.sum(axis=1, keepdims=True),
+            1e-12
+        )
 
-        weights = train_posterior[:, state]
+        return joint
 
-        positive = np.sum(
-            weights * train_targets
-        )
+    def predict_future(self, future_df):
+
+        macro_X = future_df[
+            MACRO_FEATURES
+        ].values
+
+        micro_X = future_df[
+            MICRO_FEATURES
+        ].values
 
-        negative = np.sum(
-            weights * (1 - train_targets)
+        macro_post, last_macro = (
+            self.macro.filter(
+                macro_X,
+                initial_alpha=self.last_macro
+            )
         )
 
-        posterior_up = (
-            prior_alpha + positive
-        ) / (
-            prior_alpha + prior_beta
-            + positive + negative
+        micro_post, last_micro = (
+            self.micro.filter(
+                micro_X,
+                initial_alpha=self.last_micro
+            )
         )
 
-        regime_probabilities.append(
-            posterior_up
+        joint = self.combine(
+            macro_post,
+            micro_post
         )
 
-    regime_probabilities = np.asarray(
-        regime_probabilities
-    )
+        self.last_macro = last_macro
 
-    # Bayesian mixture over HMM regime probabilities
-    long_probabilities = (
-        future_posterior @ regime_probabilities
-    )
+        self.last_micro = last_micro
 
-    return (
-        long_probabilities,
-        regime_probabilities
-    )
+        return joint
 
 
 # ============================================================
-# FIT REGIME MODEL AND BAYESIAN PROBABILITY
+# BAYESIAN REGIME MODEL
 # ============================================================
 
-def fit_predict_regimes(train_df, train_y, future_df):
+class BayesianRegimeModel:
 
-    hmm = HMMRegime().fit(train_df)
+    def __init__(self):
 
-    train_posterior, last_alpha = hmm.filter(
-        train_df
-    )
+        self.prior_alpha = 2.0
 
-    future_posterior, _ = hmm.filter(
-        future_df,
-        initial_alpha=last_alpha
-    )
+        self.prior_beta = 2.0
 
-    probabilities, regime_probabilities = (
-        bayesian_regime_probability(
-            train_posterior,
-            train_y,
-            future_posterior
-        )
-    )
-
-    return {
-        "probabilities": probabilities,
-        "train_posterior": train_posterior,
-        "future_posterior": future_posterior,
-        "regime_probabilities": regime_probabilities,
-        "hmm": hmm
-    }
+        self.state_probabilities = None
 
+    def fit(
+        self,
+        joint_posterior,
+        targets
+    ):
 
-# ============================================================
-# SEQUENTIAL PROBABILITY RATIO TEST
-# ============================================================
+        targets = np.asarray(
+            targets,
+            dtype=float
+        )
 
-def sprt_test(
-    raw,
-    raw_index,
-    window=24,
-    p1=0.60,
-    alpha=0.10,
-    beta=0.10
-):
+        probabilities = []
 
-    if raw_index < window:
-        return "INSUFFICIENT", 0.0, 0.0
+        for state in range(N_JOINT):
 
-    returns = np.log(
-        raw["close"].iloc[
-            raw_index - window + 1:raw_index + 1
-        ].values
-    )
+            weights = joint_posterior[:, state]
 
-    returns = np.diff(returns)
+            positive = np.sum(
+                weights * targets
+            )
 
-    if len(returns) == 0:
-        return "INSUFFICIENT", 0.0, 0.0
+            negative = np.sum(
+                weights * (1 - targets)
+            )
 
-    signs = np.sign(returns)
+            posterior_up = (
+                self.prior_alpha + positive
+            ) / (
+                self.prior_alpha
+                + self.prior_beta
+                + positive
+                + negative
+            )
 
-    up_count = np.sum(signs > 0)
+            probabilities.append(
+                posterior_up
+            )
 
-    down_count = np.sum(signs < 0)
+        self.state_probabilities = np.asarray(
+            probabilities
+        )
 
-    # Neutral returns are not counted.
-    p0 = 0.50
+        return self
 
-    log_up = np.log(p1 / p0)
+    def predict(self, joint_posterior):
 
-    log_down = np.log(
-        (1 - p1) / (1 - p0)
-    )
+        return (
+            joint_posterior
+            @ self.state_probabilities
+        )
 
-    long_llr = (
-        up_count * log_up
-        + down_count * log_down
-    )
 
-    short_llr = (
-        down_count * log_up
-        + up_count * log_down
-    )
+# ============================================================
+# COMPLETE MODEL FIT
+# ============================================================
 
-    upper_boundary = np.log(
-        (1 - beta) / alpha
-    )
+def fit_predict(
+    train_df,
+    future_df
+):
 
-    if long_llr >= upper_boundary:
+    if len(train_df) < MIN_TRAIN_ROWS:
+        raise ValueError(
+            "HMM eğitimi için yeterli veri yok."
+        )
 
-        decision = "LONG"
+    hierarchy = HierarchicalHMM()
 
-    elif short_llr >= upper_boundary:
+    train_joint = hierarchy.fit(
+        train_df
+    )
 
-        decision = "SHORT"
+    bayesian = BayesianRegimeModel()
 
-    else:
+    bayesian.fit(
+        train_joint,
+        train_df["target"].values
+    )
 
-        decision = "NO CONFIRMATION"
+    future_joint = hierarchy.predict_future(
+        future_df
+    )
 
-    return (
-        decision,
-        float(long_llr),
-        float(short_llr)
+    probabilities = bayesian.predict(
+        future_joint
     )
 
+    return {
+        "probabilities": probabilities,
+        "joint": future_joint,
+        "macro_micro_compatibility": hierarchy.compatibility,
+        "state_probabilities": bayesian.state_probabilities,
+        "hierarchy": hierarchy
+    }
+
 
 # ============================================================
-# BACKTEST
+# BACKTEST ENGINE
 # ============================================================
 
 def simulate_trades(
     raw,
     dataset,
-    row_indices,
+    indices,
     probabilities,
     threshold,
     stop_multiplier,
     horizon,
     fee_rate,
-    slippage_bps,
-    sprt_window
+    slippage_bps
 ):
 
     trades = []
 
-    if len(row_indices) == 0:
+    if len(indices) == 0:
         return trades
 
-    last_raw_index = int(
-        dataset.iloc[row_indices[-1]]["raw_i"]
+    last_raw_i = int(
+        dataset.iloc[indices[-1]]["raw_i"]
     )
 
     cost = (
@@ -606,29 +762,32 @@ def simulate_trades(
         + 2 * slippage_bps / 10000
     )
 
-    last_exit_index = -1
+    last_exit_i = -1
 
-    for row_index, probability in zip(
-        row_indices,
+    for row_i, probability in zip(
+        indices,
         probabilities
     ):
 
-        row = dataset.iloc[row_index]
+        row = dataset.iloc[row_i]
 
-        raw_i = int(row["raw_i"])
+        signal_raw_i = int(
+            row["raw_i"]
+        )
 
-        entry_i = raw_i + 1
+        entry_i = signal_raw_i + 1
 
-        exit_limit = entry_i + horizon - 1
+        exit_limit = (
+            entry_i + int(horizon) - 1
+        )
 
-        if exit_limit > last_raw_index:
+        if exit_limit > last_raw_i:
             continue
 
         if exit_limit >= len(raw):
             continue
 
-        # Prevent overlapping positions.
-        if entry_i <= last_exit_index:
+        if entry_i <= last_exit_i:
             continue
 
         if probability >= threshold:
@@ -643,18 +802,6 @@ 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"]
         )
@@ -663,22 +810,23 @@ def simulate_trades(
             row["realized_volatility"]
         )
 
-        if not np.isfinite(volatility) or volatility <= 0:
+        if (
+            not np.isfinite(volatility)
+            or volatility <= 0
+        ):
             continue
 
-        risk_pct = (
-            volatility *
-            np.sqrt(horizon) *
-            stop_multiplier
-        )
-
         risk_pct = np.clip(
-            risk_pct,
+            volatility
+            * np.sqrt(horizon)
+            * stop_multiplier,
             0.002,
             0.05
         )
 
-        distance = entry_price * risk_pct
+        distance = (
+            entry_price * risk_pct
+        )
 
         if direction == 1:
 
@@ -693,36 +841,47 @@ def simulate_trades(
             target = entry_price - 2 * distance
 
         exit_price = None
+
         reason = "TIME"
 
-        for j in range(entry_i, exit_limit + 1):
+        for j in range(
+            entry_i,
+            exit_limit + 1
+        ):
 
             candle = raw.iloc[j]
 
             high = float(candle["high"])
+
             low = float(candle["low"])
 
             if direction == 1:
 
                 hit_stop = low <= stop
+
                 hit_target = high >= target
 
             else:
 
                 hit_stop = high >= stop
+
                 hit_target = low <= target
 
-            # Conservative same-candle assumption.
+            # Conservative same-candle rule.
             if hit_stop:
 
                 exit_price = stop
+
                 reason = "STOP"
+
                 break
 
             if hit_target:
 
                 exit_price = target
+
                 reason = "TARGET"
+
                 break
 
         if exit_price is None:
@@ -733,27 +892,32 @@ def simulate_trades(
 
         if direction == 1:
 
-            gross = exit_price / entry_price - 1
+            gross = (
+                exit_price / entry_price - 1
+            )
 
         else:
 
-            gross = entry_price / exit_price - 1
+            gross = (
+                entry_price / exit_price - 1
+            )
 
         net = gross - cost
 
         trades.append({
-            "direction": "LONG" if direction == 1 else "SHORT",
+            "direction": (
+                "LONG" if direction == 1
+                else "SHORT"
+            ),
             "entry": entry_price,
             "exit": exit_price,
             "probability": float(probability),
-            "long_llr": long_llr,
-            "short_llr": short_llr,
             "reason": reason,
             "gross_return": gross,
             "net_return": net
         })
 
-        last_exit_index = exit_limit
+        last_exit_i = exit_limit
 
     return trades
 
@@ -768,15 +932,16 @@ def calculate_metrics(trades):
 
         return {
             "trades": 0,
-            "win_rate": 0,
-            "profit_factor": 0,
-            "net_return": 0,
-            "max_drawdown": 0
+            "win_rate": 0.0,
+            "profit_factor": 0.0,
+            "net_return": 0.0,
+            "max_drawdown": 0.0
         }
 
-    returns = np.asarray([
-        t["net_return"] for t in trades
-    ])
+    returns = np.asarray(
+        [t["net_return"] for t in trades],
+        dtype=float
+    )
 
     wins = returns[returns > 0]
 
@@ -784,192 +949,182 @@ def calculate_metrics(trades):
 
     if len(losses):
 
-        pf = wins.sum() / abs(losses.sum())
+        pf = (
+            wins.sum()
+            / abs(losses.sum())
+        )
 
     elif len(wins):
 
-        pf = 5.0
+        pf = 999.0
 
     else:
 
         pf = 0.0
 
-    equity = np.cumprod(1 + returns)
+    equity = np.cumprod(
+        1 + returns
+    )
 
     peaks = np.maximum.accumulate(
-        np.insert(equity, 0, 1)
+        np.concatenate([
+            [1.0],
+            equity
+        ])
     )[1:]
 
-    dd = 1 - equity / peaks
+    drawdown = (
+        1 - equity / peaks
+    )
 
     return {
         "trades": len(trades),
-        "win_rate": len(wins) / len(trades),
-        "profit_factor": float(min(pf, 5)),
-        "net_return": float(equity[-1] - 1),
-        "max_drawdown": float(dd.max())
+        "win_rate": float(
+            np.mean(returns > 0)
+        ),
+        "profit_factor": float(pf),
+        "net_return": float(
+            equity[-1] - 1
+        ),
+        "max_drawdown": float(
+            np.max(drawdown)
+        )
     }
 
 
 # ============================================================
-# WALK-FORWARD
+# OPTUNA DEVELOPMENT
 # ============================================================
 
-def walk_forward(
+def optimize_parameters(
     dataset,
     raw,
     horizon,
-    threshold,
-    stop_multiplier,
     fee_rate,
     slippage_bps,
-    sprt_window
+    trials
 ):
 
-    from sklearn.model_selection import TimeSeriesSplit
-
-    splitter = TimeSeriesSplit(
-        n_splits=3,
-        gap=horizon
-    )
-
-    all_trades = []
-    reports = []
-
-    for fold, (train_idx, val_idx) in enumerate(
-        splitter.split(dataset),
-        start=1
-    ):
-
-        train_df = dataset.iloc[
-            train_idx
-        ].reset_index(drop=True)
-
-        val_df = dataset.iloc[
-            val_idx
-        ].reset_index(drop=True)
-
-        train_y = train_df["target"].values.astype(int)
+    n = len(dataset)
 
-        result = fit_predict_regimes(
-            train_df,
-            train_y,
-            val_df
-        )
+    dev_end = int(n * 0.60)
 
-        probabilities = result["probabilities"]
+    development = dataset.iloc[
+        :dev_end
+    ].reset_index(drop=True)
 
-        trades = simulate_trades(
-            raw,
-            dataset,
-            val_idx,
-            probabilities,
-            threshold,
-            stop_multiplier,
-            horizon,
-            fee_rate,
-            slippage_bps,
-            sprt_window
+    if len(development) < MIN_TRAIN_ROWS + 150:
+        raise ValueError(
+            "Optimizasyon için daha fazla veri gerekli."
         )
 
-        metrics = calculate_metrics(trades)
-
-        all_trades.extend(trades)
-
-        reports.append({
-            "fold": fold,
-            **metrics
-        })
-
-    return calculate_metrics(all_trades), reports
-
-
-# ============================================================
-# OPTUNA
-# ============================================================
-
-def optimize(
-    dataset,
-    raw,
-    horizon,
-    fee_rate,
-    slippage_bps,
-    trials
-):
-
-    from sklearn.model_selection import TimeSeriesSplit
-
-    splitter = TimeSeriesSplit(
-        n_splits=3,
-        gap=horizon
+    # Three chronological development folds.
+    boundaries = np.linspace(
+        int(len(development) * 0.50),
+        len(development),
+        4,
+        dtype=int
     )
 
     def objective(trial):
 
         threshold = trial.suggest_float(
             "threshold",
-            0.55,
-            0.80
+            0.54,
+            0.72
         )
 
         stop_multiplier = trial.suggest_float(
             "stop_multiplier",
-            0.7,
-            2.5
+            0.8,
+            2.2
         )
 
-        sprt_window = trial.suggest_categorical(
-            "sprt_window",
-            [12, 18, 24, 36, 48]
-        )
+        fold_scores = []
 
-        scores = []
+        total_trades = 0
 
-        for train_idx, val_idx in splitter.split(dataset):
+        for k in range(3):
 
-            train_df = dataset.iloc[
-                train_idx
-            ].reset_index(drop=True)
+            val_start = boundaries[k]
+
+            val_end = boundaries[k + 1]
+
+            train_end = val_start - horizon
+
+            if train_end < MIN_TRAIN_ROWS:
+                continue
 
-            val_df = dataset.iloc[
-                val_idx
+            train_df = development.iloc[
+                :train_end
             ].reset_index(drop=True)
 
-            train_y = train_df["target"].values.astype(int)
+            # Includes the purge/gap observations.
+            future_df = development.iloc[
+                train_end:val_end
+            ].reset_index(drop=True)
 
-            result = fit_predict_regimes(
+            result = fit_predict(
                 train_df,
-                train_y,
-                val_df
+                future_df
+            )
+
+            offset = val_start - train_end
+
+            val_probabilities = (
+                result["probabilities"][offset:]
+            )
+
+            # Map development-local indices to original dataset.
+            global_start = val_start
+
+            global_end = val_end
+
+            indices = np.arange(
+                global_start,
+                global_end
             )
 
             trades = simulate_trades(
                 raw,
                 dataset,
-                val_idx,
-                result["probabilities"],
+                indices,
+                val_probabilities,
                 threshold,
                 stop_multiplier,
                 horizon,
                 fee_rate,
-                slippage_bps,
-                sprt_window
+                slippage_bps
+            )
+
+            metrics = calculate_metrics(
+                trades
             )
 
-            metrics = calculate_metrics(trades)
+            total_trades += metrics["trades"]
 
             score = (
                 metrics["net_return"] * 100
-                + min(metrics["profit_factor"], 3) * 1.5
-                - metrics["max_drawdown"] * 40
+                + min(metrics["profit_factor"], 4) * 1.5
+                + metrics["win_rate"] * 2
+                - metrics["max_drawdown"] * 20
             )
 
-            if metrics["trades"] < 3:
-                score -= 5
+            fold_scores.append(score)
 
-            scores.append(score)
+        if not fold_scores:
+            return -100.0
 
-        return float(np.mean(scores))
+        # Avoid selecting a model that makes almost no trades.
+        if total_trades < 8:
+            return (
+                float(np.mean(fold_scores))
+                - (8 - total_trades) * 2
+            )
+
+        return float(
+            np.mean(fold_scores)
+        )
 
     study = optuna.create_study(
         direction="maximize",
@@ -980,7 +1135,7 @@ def optimize(
 
     study.optimize(
         objective,
-        n_trials=trials,
+        n_trials=int(trials),
         show_progress_bar=False
     )
 
@@ -988,18 +1143,107 @@ def optimize(
 
 
 # ============================================================
-# HOLDOUT
+# WALK-FORWARD EVALUATION
 # ============================================================
 
-def holdout_test(
+def walk_forward_evaluation(
     dataset,
     raw,
     horizon,
-    threshold,
-    stop_multiplier,
+    params,
     fee_rate,
-    slippage_bps,
-    sprt_window
+    slippage_bps
+):
+
+    n = len(dataset)
+
+    start = int(n * 0.60)
+
+    end = int(n * 0.80)
+
+    boundaries = np.linspace(
+        start,
+        end,
+        5,
+        dtype=int
+    )
+
+    all_trades = []
+
+    fold_reports = []
+
+    for fold in range(4):
+
+        val_start = boundaries[fold]
+
+        val_end = boundaries[fold + 1]
+
+        train_end = val_start - horizon
+
+        train_df = dataset.iloc[
+            :train_end
+        ].reset_index(drop=True)
+
+        future_df = dataset.iloc[
+            train_end:val_end
+        ].reset_index(drop=True)
+
+        result = fit_predict(
+            train_df,
+            future_df
+        )
+
+        offset = val_start - train_end
+
+        probabilities = (
+            result["probabilities"][offset:]
+        )
+
+        indices = np.arange(
+            val_start,
+            val_end
+        )
+
+        trades = simulate_trades(
+            raw,
+            dataset,
+            indices,
+            probabilities,
+            params["threshold"],
+            params["stop_multiplier"],
+            horizon,
+            fee_rate,
+            slippage_bps
+        )
+
+        metrics = calculate_metrics(
+            trades
+        )
+
+        fold_reports.append({
+            "fold": fold + 1,
+            **metrics
+        })
+
+        all_trades.extend(trades)
+
+    return (
+        calculate_metrics(all_trades),
+        fold_reports
+    )
+
+
+# ============================================================
+# INDEPENDENT HOLDOUT
+# ============================================================
+
+def independent_holdout(
+    dataset,
+    raw,
+    horizon,
+    params,
+    fee_rate,
+    slippage_bps
 ):
 
     n = len(dataset)
@@ -1012,19 +1256,23 @@ def holdout_test(
         :train_end
     ].reset_index(drop=True)
 
-    test_df = dataset.iloc[
-        split:
+    # Includes purge observations before holdout.
+    future_df = dataset.iloc[
+        train_end:n
     ].reset_index(drop=True)
 
-    train_y = train_df["target"].values.astype(int)
-
-    result = fit_predict_regimes(
+    result = fit_predict(
         train_df,
-        train_y,
-        test_df
+        future_df
+    )
+
+    offset = split - train_end
+
+    probabilities = (
+        result["probabilities"][offset:]
     )
 
-    test_indices = np.arange(
+    indices = np.arange(
         split,
         n
     )
@@ -1032,62 +1280,78 @@ def holdout_test(
     trades = simulate_trades(
         raw,
         dataset,
-        test_indices,
-        result["probabilities"],
-        threshold,
-        stop_multiplier,
+        indices,
+        probabilities,
+        params["threshold"],
+        params["stop_multiplier"],
         horizon,
         fee_rate,
-        slippage_bps,
-        sprt_window
+        slippage_bps
     )
 
-    metrics = calculate_metrics(trades)
-
-    return metrics, result
+    return (
+        calculate_metrics(trades),
+        trades
+    )
 
 
 # ============================================================
-# OVERFIT INDICATOR
+# OVERFIT DIAGNOSTIC
 # ============================================================
 
-def overfit_indicator(wf, holdout):
+def overfit_diagnostic(wf, holdout):
 
-    # Heuristic generalization-gap indicator.
-    # Not a statistically calibrated probability.
+    if (
+        wf["trades"] < MIN_RELIABLE_TRADES
+        or holdout["trades"] < MIN_RELIABLE_TRADES
+    ):
 
-    gap = max(
-        0,
+        return (
+            None,
+            "YETERSİZ VERİ",
+            "Her iki test bölümünde de en az 30 işlem gerekli."
+        )
+
+    win_gap = abs(
         wf["win_rate"] - holdout["win_rate"]
     )
 
-    pf_gap = max(
-        0,
-        wf["profit_factor"] - holdout["profit_factor"]
+    pf_gap = abs(
+        min(wf["profit_factor"], 5)
+        - min(holdout["profit_factor"], 5)
+    ) / 5
+
+    return_gap = abs(
+        wf["net_return"] - holdout["net_return"]
     )
 
-    score = max(
-        gap * 150,
-        pf_gap * 15
+    score = (
+        win_gap * 40
+        + pf_gap * 35
+        + min(return_gap, 1) * 25
     )
 
     score = float(
         np.clip(score, 0, 100)
     )
 
-    if score < 15:
-        label = "DÜŞÜK"
+    if score < 20:
+        label = "DÜŞÜK FARK"
 
-    elif score < 35:
-        label = "ORTA"
+    elif score < 40:
+        label = "ORTA FARK"
 
-    elif score < 60:
-        label = "YÜKSEK"
+    elif score < 65:
+        label = "YÜKSEK FARK"
 
     else:
-        label = "ÇOK YÜKSEK"
+        label = "ÇOK YÜKSEK FARK"
 
-    return score, label
+    return (
+        score,
+        label,
+        "Bu değer gerçek overfit olasılığı değil, test bölümleri arasındaki performans farkıdır."
+    )
 
 
 # ============================================================
@@ -1096,57 +1360,46 @@ def overfit_indicator(wf, holdout):
 
 def live_prediction(
     dataset,
-    raw,
+    live,
     horizon,
     params
 ):
 
-    train_y = dataset["target"].values.astype(int)
+    train_df = dataset.copy()
 
-    latest = dataset.tail(1).reset_index(drop=True)
-
-    # Final model: all currently labeled data.
-    result = fit_predict_regimes(
-        dataset,
-        train_y,
-        latest
+    train_end_raw_i = int(
+        train_df["raw_i"].iloc[-1]
     )
 
-    long_probability = float(
-        result["probabilities"][-1]
-    )
-
-    short_probability = 1 - long_probability
-
-    hmm_posterior = result["future_posterior"][-1]
-
-    threshold = params["threshold"]
+    future_df = live[
+        live["raw_i"] > train_end_raw_i
+    ].copy()
 
-    stop_multiplier = params["stop_multiplier"]
+    if future_df.empty:
+        raise ValueError(
+            "Canlı tahmin için yeni tamamlanmış mum bulunamadı."
+        )
 
-    sprt_window = params["sprt_window"]
+    future_df = future_df.reset_index(
+        drop=True
+    )
 
-    raw_i = int(
-        latest.iloc[0]["raw_i"]
+    result = fit_predict(
+        train_df,
+        future_df
     )
 
-    sprt_decision, long_llr, short_llr = sprt_test(
-        raw,
-        raw_i,
-        window=sprt_window
+    probability = float(
+        result["probabilities"][-1]
     )
 
-    if (
-        long_probability >= threshold
-        and sprt_decision == "LONG"
-    ):
+    threshold = params["threshold"]
+
+    if probability >= threshold:
 
         signal = "LONG"
 
-    elif (
-        short_probability >= threshold
-        and sprt_decision == "SHORT"
-    ):
+    elif probability <= 1 - threshold:
 
         signal = "SHORT"
 
@@ -1154,16 +1407,20 @@ def live_prediction(
 
         signal = "NO TRADE"
 
+    latest = future_df.iloc[-1]
+
     price = float(
-        latest.iloc[0]["close"]
+        latest["close"]
     )
 
     volatility = float(
-        latest.iloc[0]["realized_volatility"]
+        latest["realized_volatility"]
     )
 
     risk_pct = np.clip(
-        volatility * np.sqrt(horizon) * stop_multiplier,
+        volatility
+        * np.sqrt(horizon)
+        * params["stop_multiplier"],
         0.002,
         0.05
     )
@@ -1173,36 +1430,52 @@ def live_prediction(
     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
 
+    joint = result["joint"][-1]
+
+    macro_prob = joint.reshape(
+        N_MACRO,
+        N_MICRO
+    ).sum(axis=1)
+
+    micro_prob = joint.reshape(
+        N_MACRO,
+        N_MICRO
+    ).sum(axis=0)
+
     return {
         "signal": signal,
-        "long": long_probability,
-        "short": short_probability,
+        "long_probability": probability,
+        "short_probability": 1 - probability,
         "price": price,
         "stop": stop,
         "target": target,
         "risk_pct": risk_pct,
-        "regimes": hmm_posterior,
-        "sprt": sprt_decision,
-        "long_llr": long_llr,
-        "short_llr": short_llr,
-        "regime_bayes": result["regime_probabilities"]
+        "macro": macro_prob,
+        "micro": micro_prob,
+        "joint": joint,
+        "state_probabilities": result[
+            "state_probabilities"
+        ]
     }
 
 
 # ============================================================
-# MAIN
+# MAIN APPLICATION
 # ============================================================
 
 def run_app(
@@ -1219,7 +1492,9 @@ def run_app(
             optuna.logging.WARNING
         )
 
-        fee_rate = fee_percent / 100
+        fee_rate = (
+            float(fee_percent) / 100
+        )
 
         raw = fetch_data(
             int(candle_count)
@@ -1230,20 +1505,9 @@ def run_app(
             int(horizon)
         )
 
-        split = int(len(dataset) * 0.80)
-
-        development = dataset.iloc[
-            :split - int(horizon)
-        ].reset_index(drop=True)
-
-        if len(development) < 300:
-            raise ValueError(
-                "Optimizasyon için veri yetersiz."
-            )
-
-        # 1. OPTUNA
-        best_params, best_score = optimize(
-            development,
+        # 1. Optimize only on first 60%.
+        params, best_score = optimize_parameters(
+            dataset,
             raw,
             int(horizon),
             fee_rate,
@@ -1251,157 +1515,181 @@ def run_app(
             int(trials)
         )
 
-        # 2. WALK FORWARD
-        wf, fold_reports = walk_forward(
-            development,
+        # 2. Walk-forward: 60%-80%.
+        wf, fold_reports = walk_forward_evaluation(
+            dataset,
             raw,
             int(horizon),
-            best_params["threshold"],
-            best_params["stop_multiplier"],
+            params,
             fee_rate,
-            float(slippage_bps),
-            best_params["sprt_window"]
+            float(slippage_bps)
         )
 
-        # 3. INDEPENDENT HOLDOUT
-        holdout, holdout_result = holdout_test(
+        # 3. Independent holdout: last 20%.
+        holdout, holdout_trades = independent_holdout(
             dataset,
             raw,
             int(horizon),
-            best_params["threshold"],
-            best_params["stop_multiplier"],
+            params,
             fee_rate,
-            float(slippage_bps),
-            best_params["sprt_window"]
+            float(slippage_bps)
         )
 
-        # 4. OVERFIT
-        overfit_score, overfit_label = overfit_indicator(
-            wf,
-            holdout
+        # 4. Overfit diagnostic.
+        overfit_score, overfit_label, overfit_note = (
+            overfit_diagnostic(
+                wf,
+                holdout
+            )
         )
 
-        # 5. LIVE
+        # 5. Live model.
         live_result = live_prediction(
             dataset,
-            raw,
+            live,
             int(horizon),
-            best_params
+            params
         )
 
-        last_time = pd.to_datetime(
+        last_timestamp = pd.to_datetime(
             int(raw.iloc[-1]["timestamp"]),
             unit="ms",
             utc=True
         )
 
-        regimes = live_result["regimes"]
+        macro = live_result["macro"]
 
-        bayes = live_result["regime_bayes"]
+        micro = live_result["micro"]
 
-        report = f"""
-# OKX BTC/USDT QUANT ENGINE
+        state_probs = live_result[
+            "state_probabilities"
+        ]
 
-<badge color="success">HMM + BAYESIAN + SPRT</badge>
+        joint = live_result["joint"]
 
-## Veri
+        def pct(x):
+            return f"%{100*x:.2f}"
 
-| Metrik | Sonuç |
-|---|---:|
-| Ham mum | {len(raw)} |
-| Temiz örnek | {len(dataset)} |
-| Geliştirme örneği | {len(development)} |
-| Holdout örneği | {len(dataset)-split} |
-| Zaman dilimi | 1H |
-| Son tamamlanmış mum | {last_time} |
+        def price_text(x):
+            if x is None:
+                return "Yok"
+            return f"{x:,.2f} USDT"
+
+        report = f"""
+# OKX BTC/USDT — HIERARCHICAL QUANT
 
-## Canlı sinyal
+**Model:** Hierarchical HMM + Bayesian Regime Model
+
+## Canlı tahmin
 
 # {live_result['signal']}
 
 | Metrik | Sonuç |
 |---|---:|
-| 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 |
+| BTC fiyatı | {price_text(live_result['price'])} |
+| LONG olasılığı | {pct(live_result['long_probability'])} |
+| SHORT olasılığı | {pct(live_result['short_probability'])} |
+| Stop-loss | {price_text(live_result['stop'])} |
+| 2R hedef | {price_text(live_result['target'])} |
+| Risk mesafesi | {pct(live_result['risk_pct'])} |
+| Son mum | {last_timestamp} |
+
+## Üst katman — Macro HMM
+
+| Gizli durum | Olasılık |
 |---|---:|
-| Bearish | %{regimes[0]*100:.2f} |
-| Neutral | %{regimes[1]*100:.2f} |
-| Bullish | %{regimes[2]*100:.2f} |
+| Macro 1 | {pct(macro[0])} |
+| Macro 2 | {pct(macro[1])} |
+| Macro 3 | {pct(macro[2])} |
 
-## Bayesian rejim olasılıkları
+Bu durumların sırası her eğitimde değişebilir. Model bunları önceden bullish/bearish diye etiketlemez.
 
-| Rejim | LONG olasılığı |
+## Alt katman — Micro HMM
+
+| Gizli durum | Olasılık |
 |---|---:|
-| Bearish | %{bayes[0]*100:.2f} |
-| Neutral | %{bayes[1]*100:.2f} |
-| Bullish | %{bayes[2]*100:.2f} |
+| Micro 1 | {pct(micro[0])} |
+| Micro 2 | {pct(micro[1])} |
+
+## Birleşik altı rejim
+
+| Rejim | Olasılık | Bayesian LONG |
+|---|---:|---:|
+| M1-U1 | {pct(joint[0])} | {pct(state_probs[0])} |
+| M1-U2 | {pct(joint[1])} | {pct(state_probs[1])} |
+| M2-U1 | {pct(joint[2])} | {pct(state_probs[2])} |
+| M2-U2 | {pct(joint[3])} | {pct(state_probs[3])} |
+| M3-U1 | {pct(joint[4])} | {pct(state_probs[4])} |
+| M3-U2 | {pct(joint[5])} | {pct(state_probs[5])} |
 
-## Walk-forward backtest
+## Walk-forward — %60 ile %80 arası
 
 | Metrik | Sonuç |
 |---|---:|
 | İşlem sayısı | {wf['trades']} |
-| Win rate | %{wf['win_rate']*100:.2f} |
+| Win rate | {pct(wf['win_rate'])} |
 | Profit Factor | {wf['profit_factor']:.2f} |
-| Net getiri | %{wf['net_return']*100:.2f} |
-| Max drawdown | %{wf['max_drawdown']*100:.2f} |
+| Net getiri | {pct(wf['net_return'])} |
+| Max drawdown | {pct(wf['max_drawdown'])} |
 
-## Bağımsız holdout
+## Bağımsız holdout — Son %20
 
 | Metrik | Sonuç |
 |---|---:|
 | İşlem sayısı | {holdout['trades']} |
-| Win rate | %{holdout['win_rate']*100:.2f} |
+| Win rate | {pct(holdout['win_rate'])} |
 | Profit Factor | {holdout['profit_factor']:.2f} |
-| Net getiri | %{holdout['net_return']*100:.2f} |
-| Max drawdown | %{holdout['max_drawdown']*100:.2f} |
+| Net getiri | {pct(holdout['net_return'])} |
+| Max drawdown | {pct(holdout['max_drawdown'])} |
 
-## Overfit göstergesi
+## Overfit fark göstergesi
 
-**{overfit_label} — {overfit_score:.1f}/100**
+**{overfit_label}**
 
-Bu puan walk-forward ve holdout sonuçları arasındaki farkı gösteren sezgisel bir göstergedir; overfit olasılığı değildir.
+{(
+    f"{overfit_score:.1f}/100"
+    if overfit_score is not None
+    else "Hesaplanamadı"
+)}
+
+{overfit_note}
 
 ## Optuna parametreleri
 
 | Parametre | Değer |
 |---|---:|
-| Probability threshold | {best_params['threshold']:.4f} |
-| Stop multiplier | {best_params['stop_multiplier']:.4f} |
-| SPRT window | {best_params['sprt_window']} |
-| Optuna score | {best_score:.4f} |
+| LONG/SHORT eşiği | {params['threshold']:.4f} |
+| Stop multiplier | {params['stop_multiplier']:.4f} |
+| Optuna skoru | {best_score:.4f} |
 
 ## Walk-forward fold detayları
 
-| Fold | İşlem | Win rate | PF | Getiri |
+| Fold | İşlem | Win rate | PF | Net getiri |
 |---|---:|---:|---:|---:|
 """
 
-        for f in fold_reports:
+        for fold in fold_reports:
 
             report += (
-                f"| {f['fold']} "
-                f"| {f['trades']} "
-                f"| %{f['win_rate']*100:.2f} "
-                f"| {f['profit_factor']:.2f} "
-                f"| %{f['net_return']*100:.2f} |\n"
+                f"| {fold['fold']} "
+                f"| {fold['trades']} "
+                f"| {pct(fold['win_rate'])} "
+                f"| {fold['profit_factor']:.2f} "
+                f"| {pct(fold['net_return'])} |\n"
             )
 
         report += """
 ---
 
-**Önemli:** Backtest; funding, gerçek emir defteri derinliği, likidasyon ve gerçek emir kaymasını eksiksiz modellemez. Sonuçlar gelecekteki performansı garanti etmez.
+### Model sınırlamaları
+
+- Rejimler gizlidir; Macro 1'in daima bullish olması beklenmemelidir.
+- Forward filtering kullanılır; gelecekteki mumlar canlı rejim olasılığına girmez.
+- HMM parametreleri her eğitim döneminde yalnızca o dönemin eğitim verisiyle öğrenilir.
+- Holdout verisi Optuna optimizasyonunda kullanılmaz.
+- 30'dan az işlem varsa performans istatistikleri güvenilir kabul edilmemelidir.
+- Backtest funding, likidasyon, gerçek spread ve emir defteri derinliğini tam modellemez.
+- 2R hedefi ve sonuçlar garanti edilmiş değildir.
 """
 
         return report
@@ -1409,44 +1697,45 @@ Bu puan walk-forward ve holdout sonuçları arasındaki farkı gösteren sezgise
     except Exception as e:
 
         return (
-            "# HATA\n\n"
+            "# UYGULAMA HATASI\n\n"
             f"`{type(e).__name__}: {str(e)}`"
         )
 
 
 # ============================================================
-# GRADIO
+# GRADIO UI
 # ============================================================
 
 with gr.Blocks(
-    title="OKX Bayesian HMM Quant",
+    title="OKX Hierarchical Bayesian Quant",
     theme=gr.themes.Soft()
 ) as demo:
 
     gr.Markdown(
         """
-# BTC/USDT Bayesian Regime Engine
+# BTC/USDT Hierarchical Bayesian Quant
+
+**Macro HMM → Micro HMM → 6 latent regimes → Bayesian LONG/SHORT**
 
-**HMM + Bayesian Regime Switching + SPRT**
+OKX perpetual swap · 1H · Long + Short
 
-Klasik teknik indikatör yok.
-Yalnızca matematiksel ve olasılıksal modelleme.
+Klasik RSI, MACD, EMA veya Supertrend kullanılmaz.
 """
     )
 
     with gr.Row():
 
         candle_count = gr.Slider(
-            1000,
-            5000,
+            minimum=1000,
+            maximum=5000,
             value=3000,
             step=500,
             label="OKX mum sayısı"
         )
 
         horizon = gr.Slider(
-            2,
-            24,
+            minimum=2,
+            maximum=24,
             value=6,
             step=1,
             label="Tahmin ufku (saat)"
@@ -1455,31 +1744,31 @@ Yalnızca matematiksel ve olasılıksal modelleme.
     with gr.Row():
 
         trials = gr.Slider(
-            5,
-            50,
-            value=15,
+            minimum=5,
+            maximum=40,
+            value=10,
             step=5,
             label="Optuna denemesi"
         )
 
         fee_percent = gr.Slider(
-            0,
-            0.20,
+            minimum=0,
+            maximum=0.20,
             value=0.05,
             step=0.01,
             label="Komisyon % / taraf"
         )
 
         slippage_bps = gr.Slider(
-            0,
-            20,
+            minimum=0,
+            maximum=20,
             value=2,
             step=1,
             label="Kayma baz puan / taraf"
         )
 
     run_button = gr.Button(
-        "BAYESIAN QUANT ANALİZİ BAŞLAT",
+        "HIERARCHICAL QUANT ANALİZİ",
         variant="primary"
     )