Update app.py

app.py

@@ -5,8 +5,9 @@ warnings.filterwarnings("ignore")
 import time
 import numpy as np
 import pandas as pd
-import ccxt
 import gradio as gr
+import ccxt
+import optuna
 
 from sklearn.ensemble import (
     ExtraTreesClassifier,
@@ -27,7 +28,7 @@ from sklearn.metrics import (
 # CONFIG
 # =========================================================
 
-SYMBOL = "BTC/USDT"
+SYMBOL = "BTC/USDT:USDT"
 
 FEATURES = [
     "rsi",
@@ -49,25 +50,39 @@ FEATURES = [
 
 
 # =========================================================
-# BINANCE DATA
+# OKX DATA
 # =========================================================
 
 def fetch_data(timeframe="1h", candles=2000):
 
-    exchange = ccxt.binance({
+    exchange = ccxt.okx({
         "enableRateLimit": True,
-        "timeout": 20000
+        "timeout": 30000,
+        "options": {
+            "defaultType": "swap"
+        }
     })
 
+    exchange.load_markets()
+
+    if SYMBOL not in exchange.markets:
+        raise ValueError(
+            f"OKX sembolü bulunamadı: {SYMBOL}"
+        )
+
     timeframe_ms = exchange.parse_timeframe(timeframe) * 1000
 
-    since = exchange.milliseconds() - candles * timeframe_ms
+    since = (
+        exchange.milliseconds()
+        - candles * timeframe_ms
+    )
+
     all_rows = []
+    last_timestamp = None
 
     while len(all_rows) < candles:
 
-        remaining = candles - len(all_rows)
-        limit = min(1000, remaining)
+        limit = min(100, candles - len(all_rows))
 
         batch = exchange.fetch_ohlcv(
             SYMBOL,
@@ -79,10 +94,13 @@ def fetch_data(timeframe="1h", candles=2000):
         if not batch:
             break
 
-        all_rows.extend(batch)
+        for row in batch:
 
-        last_timestamp = batch[-1][0]
-        new_since = last_timestamp + timeframe_ms
+            if last_timestamp is None or row[0] > last_timestamp:
+                all_rows.append(row)
+                last_timestamp = row[0]
+
+        new_since = batch[-1][0] + timeframe_ms
 
         if new_since <= since:
             break
@@ -95,7 +113,7 @@ def fetch_data(timeframe="1h", candles=2000):
         time.sleep(exchange.rateLimit / 1000)
 
     if not all_rows:
-        raise RuntimeError("Binance veri döndürmedi.")
+        raise RuntimeError("OKX veri döndürmedi.")
 
     df = pd.DataFrame(
         all_rows,
@@ -120,30 +138,36 @@ def fetch_data(timeframe="1h", candles=2000):
 
     df = df.set_index("timestamp")
 
-    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.dropna()
 
-    # Son mum henüz tamamlanmamış olabilir.
-    if len(df) > 2:
+    # Tamamlanmamış son mumu çıkar.
+    if len(df) > 1:
         df = df.iloc[:-1]
 
     return df.tail(candles)
 
 
 # =========================================================
-# INDICATOR CALCULATIONS
+# INDICATORS
 # =========================================================
 
 def calculate_indicators(df):
 
     df = df.copy()
 
-    # -----------------------------------------------------
-    # ATR - Wilder RMA
-    # -----------------------------------------------------
-
+    # ATR
     previous_close = df["close"].shift(1)
 
     tr = pd.concat([
@@ -158,10 +182,7 @@ def calculate_indicators(df):
         min_periods=10
     ).mean()
 
-    # -----------------------------------------------------
     # RSI 14
-    # -----------------------------------------------------
-
     delta = df["close"].diff()
 
     gain = delta.clip(lower=0)
@@ -181,12 +202,9 @@ def calculate_indicators(df):
 
     rs = avg_gain / avg_loss.replace(0, np.nan)
 
-    df["rsi"] = 100 - (100 / (1 + rs))
+    df["rsi"] = 100 - 100 / (1 + rs)
 
-    # -----------------------------------------------------
     # MACD 12,26,9
-    # -----------------------------------------------------
-
     ema12 = df["close"].ewm(
         span=12,
         adjust=False
@@ -208,97 +226,87 @@ def calculate_indicators(df):
         df["macd"] - df["macd_signal"]
     )
 
-    # -----------------------------------------------------
     # SUPERTREND 10,3
-    # -----------------------------------------------------
-
-    multiplier = 3.0
-
     hl2 = (df["high"] + df["low"]) / 2
 
-    basic_upper = hl2 + multiplier * df["atr"]
-    basic_lower = hl2 - multiplier * df["atr"]
+    basic_upper = hl2 + 3 * df["atr"]
+    basic_lower = hl2 - 3 * df["atr"]
 
     final_upper = basic_upper.copy()
     final_lower = basic_lower.copy()
 
-    supertrend = pd.Series(
-        np.nan,
+    direction = pd.Series(
+        1.0,
         index=df.index
     )
 
-    direction = pd.Series(
-        1,
-        index=df.index,
-        dtype=float
+    supertrend = pd.Series(
+        np.nan,
+        index=df.index
     )
 
     for i in range(1, len(df)):
 
-        previous_upper = final_upper.iloc[i - 1]
-        previous_lower = final_lower.iloc[i - 1]
         previous_close_value = df["close"].iloc[i - 1]
 
-        current_upper = basic_upper.iloc[i]
-        current_lower = basic_lower.iloc[i]
-
         if (
-            current_upper < previous_upper
-            or previous_close_value > previous_upper
+            basic_upper.iloc[i] < final_upper.iloc[i - 1]
+            or previous_close_value > final_upper.iloc[i - 1]
         ):
-            final_upper.iloc[i] = current_upper
+            final_upper.iloc[i] = basic_upper.iloc[i]
         else:
-            final_upper.iloc[i] = previous_upper
+            final_upper.iloc[i] = final_upper.iloc[i - 1]
 
         if (
-            current_lower > previous_lower
-            or previous_close_value < previous_lower
+            basic_lower.iloc[i] > final_lower.iloc[i - 1]
+            or previous_close_value < final_lower.iloc[i - 1]
         ):
-            final_lower.iloc[i] = current_lower
+            final_lower.iloc[i] = basic_lower.iloc[i]
         else:
-            final_lower.iloc[i] = previous_lower
+            final_lower.iloc[i] = final_lower.iloc[i - 1]
 
-        previous_direction = direction.iloc[i - 1]
         current_close = df["close"].iloc[i]
 
-        if previous_direction == -1:
+        if direction.iloc[i - 1] == -1:
 
-            if current_close > final_upper.iloc[i]:
-                direction.iloc[i] = 1
-            else:
-                direction.iloc[i] = -1
+            direction.iloc[i] = (
+                1 if current_close > final_upper.iloc[i]
+                else -1
+            )
 
         else:
 
-            if current_close < final_lower.iloc[i]:
-                direction.iloc[i] = -1
-            else:
-                direction.iloc[i] = 1
+            direction.iloc[i] = (
+                -1 if current_close < final_lower.iloc[i]
+                else 1
+            )
 
-        if direction.iloc[i] == 1:
-            supertrend.iloc[i] = final_lower.iloc[i]
-        else:
-            supertrend.iloc[i] = final_upper.iloc[i]
+        supertrend.iloc[i] = (
+            final_lower.iloc[i]
+            if direction.iloc[i] == 1
+            else final_upper.iloc[i]
+        )
 
     df["supertrend"] = supertrend
     df["supertrend_direction"] = direction
 
-    # -----------------------------------------------------
-    # VWAP - UTC DAILY RESET
-    # -----------------------------------------------------
-
+    # UTC DAILY VWAP
     typical_price = (
         df["high"] + df["low"] + df["close"]
     ) / 3
 
     daily_group = df.index.date
 
-    pv = typical_price * df["volume"]
-
-    cumulative_pv = pv.groupby(daily_group).cumsum()
+    cumulative_pv = (
+        (typical_price * df["volume"])
+        .groupby(daily_group)
+        .cumsum()
+    )
 
     cumulative_volume = (
-        df["volume"].groupby(daily_group).cumsum()
+        df["volume"]
+        .groupby(daily_group)
+        .cumsum()
     )
 
     df["vwap"] = (
@@ -306,10 +314,7 @@ def calculate_indicators(df):
         cumulative_volume.replace(0, np.nan)
     )
 
-    # -----------------------------------------------------
-    # ADDITIONAL FEATURES
-    # -----------------------------------------------------
-
+    # FEATURES
     df["macd_pct"] = df["macd"] / df["close"] * 100
 
     df["macd_signal_pct"] = (
@@ -321,12 +326,14 @@ def calculate_indicators(df):
     )
 
     df["supertrend_distance"] = (
-        df["close"] - df["supertrend"]
-    ) / df["close"] * 100
+        (df["close"] - df["supertrend"])
+        / df["close"] * 100
+    )
 
     df["vwap_distance"] = (
-        df["close"] - df["vwap"]
-    ) / df["close"] * 100
+        (df["close"] - df["vwap"])
+        / df["close"] * 100
+    )
 
     df["atr_pct"] = df["atr"] / df["close"] * 100
 
@@ -338,31 +345,33 @@ def calculate_indicators(df):
         df["return_1"].rolling(14).std()
     )
 
-    volume_average = df["volume"].rolling(20).mean()
+    volume_avg = df["volume"].rolling(20).mean()
 
     df["volume_ratio"] = (
         df["volume"] /
-        volume_average.replace(0, np.nan)
+        volume_avg.replace(0, np.nan)
     )
 
     df["body_pct"] = (
-        df["close"] - df["open"]
-    ) / df["open"] * 100
+        (df["close"] - df["open"])
+        / df["open"] * 100
+    )
 
     df["high_low_pct"] = (
-        df["high"] - df["low"]
-    ) / df["close"] * 100
+        (df["high"] - df["low"])
+        / df["close"] * 100
+    )
 
     return df
 
 
 # =========================================================
-# TARGET
+# DATASET
 # =========================================================
 
-def prepare_dataset(df, horizon):
+def prepare_dataset(raw, horizon):
 
-    data = calculate_indicators(df)
+    data = calculate_indicators(raw)
 
     future_close = data["close"].shift(-horizon)
 
@@ -370,7 +379,7 @@ def prepare_dataset(df, horizon):
         future_close > data["close"]
     ).astype(int)
 
-    # Son horizon mumunda gelecek hedefi bilinmez.
+    # Bilinmeyen gelecek hedeflerini çıkar.
     data = data.iloc[:-horizon].copy()
 
     data = data.replace(
@@ -384,133 +393,71 @@ def prepare_dataset(df, horizon):
 
     if len(data) < 500:
         raise ValueError(
-            "Yeterli veri yok. Mum sayısını artır."
+            "Model için yeterli temiz veri bulunamadı."
         )
 
     return data
 
 
 # =========================================================
-# MODELS
+# MODEL FACTORY
 # =========================================================
 
-def create_models():
+def create_models(params):
 
-    models = {
-
-        "HistGradientBoosting":
-            HistGradientBoostingClassifier(
-                max_iter=180,
-                learning_rate=0.05,
-                max_leaf_nodes=15,
-                l2_regularization=2.0,
-                random_state=42
-            ),
-
-        "ExtraTrees":
-            ExtraTreesClassifier(
-                n_estimators=300,
-                max_depth=8,
-                min_samples_leaf=5,
-                max_features=0.8,
-                class_weight="balanced",
-                random_state=42,
-                n_jobs=-1
-            ),
+    extra = ExtraTreesClassifier(
+        n_estimators=params["extra_trees"],
+        max_depth=params["extra_depth"],
+        min_samples_leaf=params["extra_leaf"],
+        max_features=0.8,
+        class_weight="balanced",
+        random_state=42,
+        n_jobs=-1
+    )
 
-        "LogisticRegression":
-            Pipeline([
-                ("scaler", StandardScaler()),
-                ("model", LogisticRegression(
-                    C=0.2,
-                    max_iter=2000,
-                    class_weight="balanced",
-                    random_state=42
-                ))
-            ])
-    }
+    hist = HistGradientBoostingClassifier(
+        max_iter=params["hgb_iter"],
+        learning_rate=params["hgb_lr"],
+        max_leaf_nodes=params["hgb_leaves"],
+        l2_regularization=params["hgb_l2"],
+        random_state=42
+    )
 
-    return models
+    logistic = Pipeline([
+        ("scaler", StandardScaler()),
+        ("model", LogisticRegression(
+            C=params["logistic_c"],
+            max_iter=1500,
+            class_weight="balanced",
+            random_state=42
+        ))
+    ])
 
+    return [extra, hist, logistic]
 
-def ensemble_predict(X_train, y_train, X_test):
 
-    models = create_models()
+def ensemble_predict(
+    X_train,
+    y_train,
+    X_test,
+    params
+):
 
     probabilities = []
 
-    for name, model in models.items():
+    for model in create_models(params):
 
         model.fit(X_train, y_train)
 
-        probability = model.predict_proba(X_test)[:, 1]
-
-        probabilities.append(probability)
-
-    ensemble_probability = np.mean(
-        probabilities,
-        axis=0
-    )
-
-    return ensemble_probability
-
-
-# =========================================================
-# WALK FORWARD VALIDATION
-# =========================================================
-
-def walk_forward_validation(X, y):
-
-    splitter = TimeSeriesSplit(n_splits=4)
-
-    scores = []
-    fold_results = []
-
-    for fold, (train_idx, test_idx) in enumerate(
-        splitter.split(X),
-        start=1
-    ):
-
-        X_train = X.iloc[train_idx]
-        X_test = X.iloc[test_idx]
-
-        y_train = y.iloc[train_idx]
-        y_test = y.iloc[test_idx]
-
-        if y_train.nunique() < 2:
-            continue
+        p = model.predict_proba(X_test)[:, 1]
 
-        probabilities = ensemble_predict(
-            X_train,
-            y_train,
-            X_test
-        )
+        probabilities.append(p)
 
-        predictions = (
-            probabilities >= 0.5
-        ).astype(int)
-
-        score = balanced_accuracy_score(
-            y_test,
-            predictions
-        )
-
-        scores.append(score)
-
-        fold_results.append(
-            f"Fold {fold}: {score * 100:.2f}%"
-        )
-
-    if not scores:
-        raise ValueError(
-            "Walk-forward validation yapılamadı."
-        )
-
-    return np.mean(scores), fold_results
+    return np.mean(probabilities, axis=0)
 
 
 # =========================================================
-# BACKTEST
+# BACKTEST ENGINE
 # =========================================================
 
 def run_backtest(
@@ -519,30 +466,31 @@ def run_backtest(
     probabilities,
     horizon,
     threshold,
+    atr_multiplier,
     fee_pct
 ):
 
     trades = []
 
-    next_allowed_bar = -1
-
     fee_rate = fee_pct / 100
 
-    for timestamp, row in test.iterrows():
+    next_allowed = -1
+
+    raw_positions = raw.index.get_indexer(test.index)
+
+    for i, (timestamp, row) in enumerate(test.iterrows()):
 
-        raw_position = raw.index.get_loc(timestamp)
+        position = raw_positions[i]
 
-        if raw_position < next_allowed_bar:
+        if position < 0 or position < next_allowed:
             continue
 
-        probability = float(
-            probabilities[test.index.get_loc(timestamp)]
-        )
+        probability = float(probabilities[i])
 
         if probability >= threshold:
             side = "LONG"
 
-        elif probability <= (1 - threshold):
+        elif probability <= 1 - threshold:
             side = "SHORT"
 
         else:
@@ -554,21 +502,18 @@ def run_backtest(
         if not np.isfinite(atr) or atr <= 0:
             continue
 
-        risk_distance = atr * 1.5
+        risk = atr * atr_multiplier
 
         if side == "LONG":
-
-            stop = entry - risk_distance
-            target = entry + risk_distance * 2
-
+            stop = entry - risk
+            target = entry + 2 * risk
         else:
-
-            stop = entry + risk_distance
-            target = entry - risk_distance * 2
+            stop = entry + risk
+            target = entry - 2 * risk
 
         future = raw.iloc[
-            raw_position + 1:
-            raw_position + horizon + 1
+            position + 1:
+            position + horizon + 1
         ]
 
         if len(future) < horizon:
@@ -584,8 +529,8 @@ def run_backtest(
 
             if side == "LONG":
 
-                # Aynı mumda iki seviyeye de dokunursa
-                # ihtiyatlı olarak stop önce kabul edilir.
+                # Aynı mumda stop ve hedef görülürse
+                # ihtiyatlı biçimde stop önce kabul edilir.
                 if low <= stop:
                     exit_price = stop
                     exit_reason = "STOP"
@@ -609,12 +554,12 @@ def run_backtest(
                     break
 
         if side == "LONG":
-            gross_return = (exit_price - entry) / entry
-
+            gross = (exit_price - entry) / entry
         else:
-            gross_return = (entry - exit_price) / entry
+            gross = (entry - exit_price) / entry
 
-        net_return = gross_return - (2 * fee_rate)
+        # Giriş ve çıkış komisyonu
+        net = gross - 2 * fee_rate
 
         trades.append({
             "time": timestamp,
@@ -622,14 +567,12 @@ def run_backtest(
             "entry": entry,
             "exit": exit_price,
             "probability": probability,
-            "gross_return": gross_return * 100,
-            "net_return": net_return * 100,
-            "result": "WIN" if net_return > 0 else "LOSS",
+            "net_pct": net * 100,
+            "result": "WIN" if net > 0 else "LOSS",
             "exit_reason": exit_reason
         })
 
-        # Pozisyonlar çakışmasın.
-        next_allowed_bar = raw_position + horizon
+        next_allowed = position + horizon
 
     if not trades:
 
@@ -638,43 +581,263 @@ def run_backtest(
             "winrate": 0,
             "profit_factor": 0,
             "total_return": 0,
+            "max_drawdown": 0,
             "trades": []
         }
 
     trade_df = pd.DataFrame(trades)
 
-    wins = trade_df[
-        trade_df["net_return"] > 0
-    ]["net_return"]
+    wins = trade_df.loc[
+        trade_df["net_pct"] > 0,
+        "net_pct"
+    ]
 
-    losses = trade_df[
-        trade_df["net_return"] < 0
-    ]["net_return"]
+    losses = trade_df.loc[
+        trade_df["net_pct"] < 0,
+        "net_pct"
+    ]
 
     gross_profit = wins.sum()
     gross_loss = abs(losses.sum())
 
-    profit_factor = (
-        gross_profit / gross_loss
-        if gross_loss > 0
-        else float("inf") if gross_profit > 0 else 0
-    )
+    if gross_loss > 0:
+        pf = gross_profit / gross_loss
+    elif gross_profit > 0:
+        pf = float("inf")
+    else:
+        pf = 0
 
     winrate = (
         len(wins) / len(trade_df)
     ) * 100
 
-    total_return = trade_df["net_return"].sum()
+    # İşlemler sırasıyla bileşik getiri
+    returns = trade_df["net_pct"].values / 100
+
+    equity = np.cumprod(1 + returns)
+
+    peak = np.maximum.accumulate(equity)
+
+    drawdown = (
+        (equity - peak) / peak
+    ) * 100
+
+    total_return = (
+        equity[-1] - 1
+    ) * 100
 
     return {
         "count": len(trade_df),
         "winrate": winrate,
-        "profit_factor": profit_factor,
+        "profit_factor": pf,
         "total_return": total_return,
+        "max_drawdown": abs(float(drawdown.min())),
         "trades": trades
     }
 
 
+# =========================================================
+# OPTUNA OPTIMIZATION
+# =========================================================
+
+def optimize_model(
+    X,
+    y,
+    raw,
+    horizon,
+    trials,
+    fee_pct
+):
+
+    splitter = TimeSeriesSplit(n_splits=3)
+
+    splits = list(splitter.split(X))
+
+    def objective(trial):
+
+        params = {
+            "extra_trees": trial.suggest_int(
+                "extra_trees", 100, 350
+            ),
+            "extra_depth": trial.suggest_int(
+                "extra_depth", 3, 14
+            ),
+            "extra_leaf": trial.suggest_int(
+                "extra_leaf", 2, 12
+            ),
+            "hgb_iter": trial.suggest_int(
+                "hgb_iter", 80, 250
+            ),
+            "hgb_lr": trial.suggest_float(
+                "hgb_lr", 0.01, 0.15, log=True
+            ),
+            "hgb_leaves": trial.suggest_int(
+                "hgb_leaves", 7, 25
+            ),
+            "hgb_l2": trial.suggest_float(
+                "hgb_l2", 0.1, 10, log=True
+            ),
+            "logistic_c": trial.suggest_float(
+                "logistic_c", 0.01, 3, log=True
+            )
+        }
+
+        threshold = trial.suggest_float(
+            "threshold", 0.53, 0.75
+        )
+
+        atr_multiplier = trial.suggest_float(
+            "atr_multiplier", 1.0, 2.5
+        )
+
+        fold_scores = []
+
+        for train_idx, val_idx in splits:
+
+            X_train = X.iloc[train_idx]
+            X_val = X.iloc[val_idx]
+
+            y_train = y.iloc[train_idx]
+
+            if y_train.nunique() < 2:
+                continue
+
+            probs = ensemble_predict(
+                X_train,
+                y_train,
+                X_val,
+                params
+            )
+
+            val_data = pd.DataFrame(
+                index=X_val.index
+            )
+
+            val_data["close"] = raw.loc[
+                X_val.index, "close"
+            ]
+
+            val_data["atr"] = raw.loc[
+                X_val.index, "atr"
+            ]
+
+            result = run_backtest(
+                raw=raw,
+                test=val_data,
+                probabilities=probs,
+                horizon=horizon,
+                threshold=threshold,
+                atr_multiplier=atr_multiplier,
+                fee_pct=fee_pct
+            )
+
+            if result["count"] < 5:
+                fold_scores.append(-5.0)
+                continue
+
+            pf = result["profit_factor"]
+
+            if np.isinf(pf):
+                pf = 3.0
+
+            # Getiri + PF - aşırı düşüş cezası
+            score = (
+                result["total_return"]
+                + min(pf, 3.0) * 3
+                - result["max_drawdown"] * 0.5
+            )
+
+            fold_scores.append(score)
+
+        if not fold_scores:
+            return -100.0
+
+        return float(np.mean(fold_scores))
+
+    study = optuna.create_study(
+        direction="maximize",
+        sampler=optuna.samplers.TPESampler(
+            seed=42
+        )
+    )
+
+    optuna.logging.set_verbosity(
+        optuna.logging.WARNING
+    )
+
+    study.optimize(
+        objective,
+        n_trials=trials,
+        show_progress_bar=False
+    )
+
+    best = study.best_params
+
+    params = {
+        "extra_trees": best["extra_trees"],
+        "extra_depth": best["extra_depth"],
+        "extra_leaf": best["extra_leaf"],
+        "hgb_iter": best["hgb_iter"],
+        "hgb_lr": best["hgb_lr"],
+        "hgb_leaves": best["hgb_leaves"],
+        "hgb_l2": best["hgb_l2"],
+        "logistic_c": best["logistic_c"]
+    }
+
+    return (
+        params,
+        best["threshold"],
+        best["atr_multiplier"],
+        study.best_value,
+        len(study.trials)
+    )
+
+
+# =========================================================
+# WALK FORWARD VALIDATION
+# =========================================================
+
+def walk_forward_validation(X, y, params):
+
+    splitter = TimeSeriesSplit(n_splits=4)
+
+    scores = []
+
+    for train_idx, test_idx in splitter.split(X):
+
+        X_train = X.iloc[train_idx]
+        X_test = X.iloc[test_idx]
+
+        y_train = y.iloc[train_idx]
+        y_test = y.iloc[test_idx]
+
+        if y_train.nunique() < 2:
+            continue
+
+        probabilities = ensemble_predict(
+            X_train,
+            y_train,
+            X_test,
+            params
+        )
+
+        predictions = (
+            probabilities >= 0.5
+        ).astype(int)
+
+        scores.append(
+            balanced_accuracy_score(
+                y_test,
+                predictions
+            )
+        )
+
+    if not scores:
+        return 0
+
+    return float(np.mean(scores))
+
+
 # =========================================================
 # MAIN ANALYSIS
 # =========================================================
@@ -683,7 +846,7 @@ def analyze(
     timeframe,
     candles,
     horizon,
-    threshold,
+    trials,
     fee_pct
 ):
 
@@ -691,30 +854,29 @@ def analyze(
 
         candles = int(candles)
         horizon = int(horizon)
-        threshold = float(threshold)
+        trials = int(trials)
         fee_pct = float(fee_pct)
 
-        if candles < 700:
-            return "En az 700 mum gerekli."
+        if candles < 800:
+            return "En az 800 mum seç."
 
         if horizon < 1 or horizon > 48:
-            return "Horizon 1 ile 48 arasında olmalı."
+            return "Horizon 1-48 arasında olmalı."
 
-        if not 0.50 < threshold < 0.90:
-            return "Threshold 0.50 ile 0.90 arasında olmalı."
+        if trials < 5 or trials > 100:
+            return "Optuna trial sayısı 5-100 arasında olmalı."
 
         if fee_pct < 0 or fee_pct > 1:
-            return "Komisyon 0 ile 1 arasında olmalı."
+            return "Komisyon değeri geçersiz."
 
-        # -------------------------------------------------
         # DATA
-        # -------------------------------------------------
-
         raw = fetch_data(
             timeframe=timeframe,
             candles=candles
         )
 
+        indicators = calculate_indicators(raw)
+
         data = prepare_dataset(
             raw,
             horizon
@@ -723,82 +885,100 @@ def analyze(
         X = data[FEATURES]
         y = data["target"].astype(int)
 
-        # -------------------------------------------------
-        # CHRONOLOGICAL SPLIT
-        # -------------------------------------------------
+        if y.nunique() < 2:
+            return "Veri setinde yalnızca tek hedef sınıfı var."
 
+        # CHRONOLOGICAL HOLDOUT
         split = int(len(data) * 0.80)
 
-        X_train = X.iloc[:split]
-        X_test = X.iloc[split:]
+        X_dev = X.iloc[:split]
+        y_dev = y.iloc[:split]
 
-        y_train = y.iloc[:split]
+        X_test = X.iloc[split:]
         y_test = y.iloc[split:]
 
-        if y_train.nunique() < 2:
+        if y_dev.nunique() < 2:
             return "Eğitim verisinde iki sınıf da bulunmalı."
 
-        # -------------------------------------------------
-        # WALK FORWARD
-        # -------------------------------------------------
-
-        wf_score, fold_results = walk_forward_validation(
-            X_train,
-            y_train
+        # OPTUNA
+        params, threshold, atr_mult, best_score, n_trials = (
+            optimize_model(
+                X=X_dev,
+                y=y_dev,
+                raw=indicators,
+                horizon=horizon,
+                trials=trials,
+                fee_pct=fee_pct
+            )
         )
 
-        # -------------------------------------------------
-        # FINAL HOLDOUT
-        # -------------------------------------------------
+        # WALK FORWARD
+        wf_score = walk_forward_validation(
+            X_dev,
+            y_dev,
+            params
+        )
 
-        probabilities = ensemble_predict(
-            X_train,
-            y_train,
-            X_test
+        # HOLDOUT PREDICTION
+        test_probs = ensemble_predict(
+            X_dev,
+            y_dev,
+            X_test,
+            params
         )
 
-        predictions = (
-            probabilities >= 0.5
+        test_predictions = (
+            test_probs >= 0.5
         ).astype(int)
 
         accuracy = accuracy_score(
             y_test,
-            predictions
+            test_predictions
         )
 
         balanced = balanced_accuracy_score(
             y_test,
-            predictions
+            test_predictions
         )
 
         try:
             auc = roc_auc_score(
                 y_test,
-                probabilities
+                test_probs
             )
         except Exception:
             auc = 0.5
 
-        # -------------------------------------------------
-        # BACKTEST
-        # -------------------------------------------------
+        # HOLDOUT BACKTEST
+        test_data = pd.DataFrame(
+            index=X_test.index
+        )
+
+        test_data["close"] = indicators.loc[
+            X_test.index, "close"
+        ]
+
+        test_data["atr"] = indicators.loc[
+            X_test.index, "atr"
+        ]
 
         backtest = run_backtest(
-            raw=raw,
-            test=data.iloc[split:],
-            probabilities=probabilities,
+            raw=indicators,
+            test=test_data,
+            probabilities=test_probs,
             horizon=horizon,
             threshold=threshold,
+            atr_multiplier=atr_mult,
             fee_pct=fee_pct
         )
 
-        # -------------------------------------------------
-        # CURRENT SIGNAL
-        # -------------------------------------------------
-
-        latest = calculate_indicators(raw).dropna(
+        # LIVE MODEL: development data only
+        # Holdout is not used for final model fitting.
+        latest_indicators = indicators.dropna(
             subset=FEATURES + ["atr"]
-        ).iloc[-1]
+        )
+
+        latest = latest_indicators.iloc[-1]
 
         latest_X = pd.DataFrame(
             [latest[FEATURES].values],
@@ -806,9 +986,10 @@ def analyze(
         )
 
         latest_probability = ensemble_predict(
-            X,
-            y,
-            latest_X
+            X_dev,
+            y_dev,
+            latest_X,
+            params
         )[0]
 
         p_up = float(latest_probability)
@@ -816,107 +997,114 @@ def analyze(
 
         if p_up >= threshold:
             signal = "LONG"
-
         elif p_down >= threshold:
             signal = "SHORT"
-
         else:
             signal = "NÖTR"
 
-        # -------------------------------------------------
-        # ENTRY / STOP / TARGET
-        # -------------------------------------------------
-
         entry = float(latest["close"])
         atr = float(latest["atr"])
 
         if signal == "LONG":
-
-            stop = entry - 1.5 * atr
-            target = entry + 3.0 * atr
+            stop = entry - atr * atr_mult
+            target = entry + atr * atr_mult * 2
 
         elif signal == "SHORT":
-
-            stop = entry + 1.5 * atr
-            target = entry - 3.0 * atr
+            stop = entry + atr * atr_mult
+            target = entry - atr * atr_mult * 2
 
         else:
-
             stop = None
             target = None
 
-        # -------------------------------------------------
-        # INDICATOR INTERPRETATION
-        # -------------------------------------------------
-
+        # INDICATORS
         rsi = float(latest["rsi"])
 
-        macd_value = float(latest["macd"])
-        macd_signal = float(latest["macd_signal"])
+        macd_state = (
+            "BULLISH"
+            if latest["macd"] > latest["macd_signal"]
+            else "BEARISH"
+        )
 
-        st_direction = int(
-            latest["supertrend_direction"]
+        supertrend_state = (
+            "BULLISH"
+            if latest["supertrend_direction"] == 1
+            else "BEARISH"
         )
 
-        vwap_distance = float(
-            latest["vwap_distance"]
+        vwap_state = (
+            "ÜSTÜNDE"
+            if latest["vwap_distance"] > 0
+            else "ALTINDA"
         )
 
-        indicator_text = (
-            f"RSI: {rsi:.2f}\n"
-            f"MACD: {'BULLISH' if macd_value > macd_signal else 'BEARISH'}\n"
-            f"Supertrend: {'BULLISH' if st_direction == 1 else 'BEARISH'}\n"
-            f"VWAP: {'ÜSTÜNDE' if vwap_distance > 0 else 'ALTINDA'}\n"
-            f"VWAP uzaklığı: {vwap_distance:.3f}%\n"
+        pf = backtest["profit_factor"]
+
+        pf_text = (
+            "∞" if np.isinf(pf)
+            else f"{pf:.2f}"
         )
 
-        # -------------------------------------------------
-        # RESULTS
-        # -------------------------------------------------
+        trade_table = ""
 
-        pf = backtest["profit_factor"]
+        if backtest["trades"]:
 
-        if np.isinf(pf):
-            pf_text = "∞"
-        else:
-            pf_text = f"{pf:.2f}"
+            trade_df = pd.DataFrame(
+                backtest["trades"]
+            )
 
-        if signal == "LONG":
-            signal_text = "LONG"
-        elif signal == "SHORT":
-            signal_text = "SHORT"
+            trade_table = trade_df.tail(15).to_markdown(
+                index=False
+            )
+
+        if stop is None:
+            stop_text = "—"
+            target_text = "—"
         else:
-            signal_text = "NÖTR"
+            stop_text = f"{stop:,.2f}"
+            target_text = f"{target:,.2f}"
 
         output = f"""
-# BTC/USDT AI ANALİZİ
-
-<badge> {signal_text} </badge>
+# OKX BTC/USDT AI ANALİZİ
 
-## Güncel tahmin
+## Güncel sinyal: {signal}
 
 | Metrik | Sonuç |
 |---|---:|
-| BTC fiyatı | {entry:,.2f} USDT |
+| OKX BTC fiyatı | {entry:,.2f} USDT |
 | LONG olasılığı | {p_up * 100:.2f}% |
 | SHORT olasılığı | {p_down * 100:.2f}% |
-| Model sinyali | **{signal}** |
+| Sinyal eşiği | {threshold:.3f} |
 | Zaman dilimi | {timeframe} |
 | Tahmin horizon | {horizon} mum |
 
-## TradingView indikatörleri
+## TradingView uyumlu indikatörler
 
-```text
-{indicator_text}
-```
+| İndikatör | Değer |
+|---|---:|
+| RSI 14 | {rsi:.2f} |
+| MACD | {macd_state} |
+| Supertrend 10,3 | {supertrend_state} |
+| VWAP | {vwap_state} |
+| VWAP uzaklığı | {latest['vwap_distance']:.3f}% |
 
 ## İşlem seviyeleri
 
 | Seviye | Fiyat |
 |---|---:|
 | Giriş | {entry:,.2f} |
-| Stop Loss | {stop:,.2f if stop is not None else "—"} |
-| 2R Hedef | {target:,.2f if target is not None else "—"} |
+| Stop Loss | {stop_text} |
+| 2R hedef | {target_text} |
+| ATR çarpanı | {atr_mult:.2f} |
+
+## Optuna optimizasyonu
+
+| Metrik | Sonuç |
+|---|---:|
+| Tamamlanan trial | {n_trials} |
+| En iyi objective | {best_score:.4f} |
+| Optimize edilen threshold | {threshold:.3f} |
+| Optimize edilen ATR | {atr_mult:.2f} |
 
 ## Bağımsız hold-out test
 
@@ -927,39 +1115,28 @@ def analyze(
 | AUC | {auc:.4f} |
 | Walk-forward Balanced Accuracy | {wf_score * 100:.2f}% |
 
-## Backtest sonuçları
+## Hold-out backtest
 
 | Metrik | Sonuç |
 |---|---:|
-| İşlem sayısı | {backtest["count"]} |
-| Win Rate | {backtest["winrate"]:.2f}% |
+| İşlem sayısı | {backtest['count']} |
+| Win Rate | {backtest['winrate']:.2f}% |
 | Profit Factor | {pf_text} |
-| Net toplam getiri | {backtest["total_return"]:.2f}% |
-| İşlem komisyonu | %{fee_pct:.3f} / taraf |
-
-## Walk-forward fold sonuçları
-
-""" + "\n".join(
-            f"- {x}" for x in fold_results
-        )
-
-        if backtest["trades"]:
-
-            trade_df = pd.DataFrame(
-                backtest["trades"]
-            )
+| Bileşik net getiri | {backtest['total_return']:.2f}% |
+| Maksimum drawdown | {backtest['max_drawdown']:.2f}% |
+| Komisyon | %{fee_pct:.3f} / taraf |
 
-            output += "\n\n## Son backtest işlemleri\n\n"
+## Son işlemler
 
-            output += trade_df.tail(15).to_markdown(
-                index=False
-            )
+{trade_table if trade_table else "Backtest döneminde işlem oluşmadı."}
 
-        output += """
+## Optuna'nın seçtiği model parametreleri
 
----
+```text
+{params}
+```
 
-**Uyarı:** Bu bir istatistiksel model tahminidir, kesin fiyat tahmini değildir. Hold-out sonuçları geçmiş veriye aittir. Komisyon, kayma ve gerçek emir gerçekleşmesi sonuçları değiştirebilir. NÖTR sinyali işlem açmama anlamına gelir.
+**Not:** Optuna yalnızca ilk %80'lik geliştirme verisinde optimize edildi. Son %20 hold-out test optimizasyona dahil edilmedi. Hold-out sonucu geçmiş performanstır; gelecekteki performans garantisi değildir.
 """
 
         return output
@@ -967,9 +1144,9 @@ def analyze(
     except Exception as e:
 
         return (
-            "# HATA\n\n"
+            "# ANALİZ HATASI\n\n"
             f"`{type(e).__name__}: {str(e)}`\n\n"
-            "Bağlantıyı, Binance erişimini ve paket kurulumlarını kontrol et."
+            "OKX bağlantısını, sembolü ve paketleri kontrol et."
         )
 
 
@@ -978,15 +1155,16 @@ def analyze(
 # =========================================================
 
 with gr.Blocks(
-    title="BTC AI Indicator Ensemble"
+    title="OKX BTC AI Optuna Backtest"
 ) as app:
 
     gr.Markdown(
         """
-# BTC AI — Indicator Ensemble
-MCP'siz, Binance verisiyle çalışan BTC/USDT tahmin sistemi.
+# OKX BTC AI — OPTUNA + BACKTEST
 
-**Supertrend + RSI + MACD + VWAP + Machine Learning**
+OKX perpetual swap verisiyle çalışan makine öğrenmesi sistemi.
+
+**Supertrend + RSI + MACD + VWAP + Ensemble ML + Optuna**
 """
     )
 
@@ -1015,7 +1193,7 @@ MCP'siz, Binance verisiyle çalışan BTC/USDT tahmin sistemi.
                 5000
             ],
             value=2000,
-            label="Mum sayısı"
+            label="OKX mum sayısı"
         )
 
     with gr.Row():
@@ -1028,24 +1206,24 @@ MCP'siz, Binance verisiyle çalışan BTC/USDT tahmin sistemi.
             label="Tahmin horizon (mum)"
         )
 
-        threshold = gr.Slider(
-            minimum=0.51,
-            maximum=0.80,
-            value=0.56,
-            step=0.01,
-            label="Sinyal güven eşiği"
+        trials = gr.Slider(
+            minimum=5,
+            maximum=100,
+            value=20,
+            step=5,
+            label="Optuna trial sayısı"
         )
 
         fee = gr.Slider(
             minimum=0,
             maximum=0.20,
-            value=0.10,
+            value=0.05,
             step=0.01,
             label="Komisyon (%) / taraf"
         )
 
     run_button = gr.Button(
-        "BTC ANALİZ ET",
+        "OKX AI ANALİZ + OPTUNA BACKTEST",
         variant="primary"
     )
 
@@ -1057,7 +1235,7 @@ MCP'siz, Binance verisiyle çalışan BTC/USDT tahmin sistemi.
             timeframe,
             candles,
             horizon,
-            threshold,
+            trials,
             fee
         ],
         outputs=output