Delete app.py

app.py

@@ -1,575 +0,0 @@
-import warnings
-warnings.filterwarnings("ignore")
-
-import numpy as np
-import pandas as pd
-import yfinance as yf
-import gradio as gr
-import plotly.graph_objects as go
-
-from sklearn.impute import SimpleImputer
-from sklearn.preprocessing import StandardScaler
-from sklearn.pipeline import Pipeline
-from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors
-from sklearn.isotonic import IsotonicRegression
-from sklearn.metrics import balanced_accuracy_score, accuracy_score
-
-APP_TITLE = "Goshawk BTCUSD Adaptive Risk Engine v3"
-HORIZON = 5
-K_GRID = [5, 7, 9, 11, 15, 21]
-SL_GRID = [0.8, 1.0, 1.2, 1.5, 1.8, 2.0, 2.5, 3.0]
-RR_GRID = [1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0]
-CLASSES = [-1, 0, 1]
-
-
-def get_btc(period):
-    df = yf.download("BTC-USD", period=period, interval="1d",
-                     auto_adjust=True, progress=False)
-    if df is None or df.empty:
-        raise ValueError("Yahoo Finance BTC verisi döndürmedi.")
-    if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.get_level_values(0)
-    df = df[["Open", "High", "Low", "Close", "Volume"]].dropna().copy()
-    df.index = pd.to_datetime(df.index)
-    return df
-
-
-def calc_atr(df, n=14):
-    pc = df.Close.shift(1)
-    tr = pd.concat([(df.High-df.Low), (df.High-pc).abs(),
-                    (df.Low-pc).abs()], axis=1).max(axis=1)
-    return tr.ewm(alpha=1/n, adjust=False).mean()
-
-
-def calc_rsi(s, n=14):
-    d = s.diff()
-    up = d.clip(lower=0).ewm(alpha=1/n, adjust=False).mean()
-    dn = (-d.clip(upper=0)).ewm(alpha=1/n, adjust=False).mean()
-    rs = up / dn.replace(0, np.nan)
-    return 100 - 100/(1+rs)
-
-
-def make_features(df):
-    c, v = df.Close, df.Volume
-    x = pd.DataFrame(index=df.index)
-    for n in [1, 2, 3, 5, 10, 20, 50]:
-        x[f"ret_{n}"] = c.pct_change(n)
-    for n in [5, 10, 20, 50]:
-        x[f"ema_gap_{n}"] = c/c.ewm(span=n, adjust=False).mean()-1
-    x["rsi_14"] = calc_rsi(c)/100
-    x["atr_pct"] = calc_atr(df)/c
-    x["range_pct"] = (df.High-df.Low)/c
-    x["body_pct"] = (df.Close-df.Open)/df.Open
-    daily_ret = c.pct_change()
-    x["vol_10"] = daily_ret.rolling(10).std()
-    x["vol_20"] = daily_ret.rolling(20).std()
-    x["volume_z20"] = (v-v.rolling(20).mean())/v.rolling(20).std().replace(0, np.nan)
-    x["volume_change"] = v.pct_change()
-    macd = c.ewm(span=12, adjust=False).mean()-c.ewm(span=26, adjust=False).mean()
-    x["macd_pct"] = macd/c
-    return x.replace([np.inf, -np.inf], np.nan), calc_atr(df)
-
-
-def regime_labels(features):
-    vol = features["vol_20"]
-    trend = features["ema_gap_20"]
-    vol_q1, vol_q2 = vol.quantile([0.33, 0.67])
-    out = []
-    for v, t in zip(vol, trend):
-        vname = "LOW_VOL" if v <= vol_q1 else ("HIGH_VOL" if v >= vol_q2 else "MID_VOL")
-        tname = "UP" if t > 0.02 else ("DOWN" if t < -0.02 else "RANGE")
-        out.append(f"{tname}_{vname}")
-    return pd.Series(out, index=features.index)
-
-
-def make_target(df, atr, horizon=HORIZON, threshold=0.20):
-    fwd = df.Close.shift(-horizon)/df.Close-1
-    band = threshold*(atr/df.Close)*np.sqrt(horizon)
-    y = np.where(fwd > band, 1, np.where(fwd < -band, -1, 0))
-    return pd.Series(y, index=df.index), fwd
-
-
-def pipe(k):
-    return Pipeline([
-        ("imputer", SimpleImputer(strategy="median")),
-        ("scale", StandardScaler()),
-        ("knn", KNeighborsClassifier(n_neighbors=int(k), weights="distance"))
-    ])
-
-
-def tune_k(X, y):
-    # Inner chronological validation, with horizon purge to avoid overlapping labels.
-    cut = int(len(X)*0.80)
-    tr_end = cut-HORIZON
-    if tr_end <= max(K_GRID)+20 or len(X)-cut < 25:
-        return 9, []
-    scores = []
-    for k in K_GRID:
-        model = pipe(k)
-        model.fit(X.iloc[:tr_end], y.iloc[:tr_end])
-        pred = model.predict(X.iloc[cut:])
-        score = balanced_accuracy_score(y.iloc[cut:], pred)
-        scores.append((float(score), int(k)))
-    scores.sort(reverse=True)
-    return scores[0][1], scores
-
-
-def calibrate_probabilities(raw_probs, raw_classes, y_cal):
-    # One-vs-rest isotonic calibration on a later, held-out calibration slice.
-    # Small calibration sets fall back to raw probabilities.
-    calibrated = np.zeros((len(raw_probs), len(CLASSES)), dtype=float)
-    for j, cls in enumerate(CLASSES):
-        if cls not in raw_classes:
-            continue
-        raw_col = raw_probs[:, list(raw_classes).index(cls)]
-        truth = (np.asarray(y_cal) == cls).astype(int)
-        if len(truth) >= 35 and len(np.unique(truth)) == 2:
-            iso = IsotonicRegression(out_of_bounds="clip")
-            iso.fit(raw_col, truth)
-            calibrated[:, j] = iso.predict(raw_col)
-        else:
-            calibrated[:, j] = raw_col
-    sums = calibrated.sum(axis=1, keepdims=True)
-    fallback = np.zeros_like(calibrated)
-    for j, cls in enumerate(CLASSES):
-        if cls in raw_classes:
-            fallback[:, j] = raw_probs[:, list(raw_classes).index(cls)]
-    fallback_sum = fallback.sum(axis=1, keepdims=True)
-    calibrated = np.where(sums > 0, calibrated/np.maximum(sums, 1e-12),
-                          fallback/np.maximum(fallback_sum, 1e-12))
-    return calibrated
-
-
-def barrier_result(df, atr_s, i, side, sl_atr, rr, horizon=HORIZON):
-    entry = float(df.Close.iloc[i])
-    av = float(atr_s.iloc[i])
-    if not np.isfinite(av) or av <= 0:
-        return None
-    stop_d = sl_atr*av
-    target_d = stop_d*rr
-    end = min(i+horizon, len(df)-1)
-    for j in range(i+1, end+1):
-        hi, lo = float(df.High.iloc[j]), float(df.Low.iloc[j])
-        if side == 1:
-            sl_hit, tp_hit = lo <= entry-stop_d, hi >= entry+target_d
-        else:
-            sl_hit, tp_hit = hi >= entry+stop_d, lo <= entry-target_d
-        # Daily candles do not reveal intraday order: resolve ambiguous bars against us.
-        if sl_hit and tp_hit:
-            return -stop_d/entry
-        if sl_hit:
-            return -stop_d/entry
-        if tp_hit:
-            return target_d/entry
-    return side*(float(df.Close.iloc[end])-entry)/entry
-
-
-def trade_r_multiple(raw_return, entry, atr_value, sl_atr, fee_pct, slip_pct):
-    risk_fraction = sl_atr*atr_value/entry
-    round_trip_cost = 2*(fee_pct+slip_pct)/100
-    net_return = raw_return-round_trip_cost
-    return net_return/max(risk_fraction, 1e-12)
-
-
-def optimize_barriers(df, atr_s, regimes, end_i, side, fee, slip, current_regime):
-    # Prefer observations from the current trend/volatility regime.
-    # If the regime has too few matured examples, fall back to all regimes.
-    results = []
-    start = max(80, end_i-650)
-    regime_indices = [
-        i for i in range(start, end_i-HORIZON)
-        if str(regimes.iloc[i]) == str(current_regime)
-    ]
-    if len(regime_indices) < 35:
-        regime_indices = list(range(start, end_i-HORIZON))
-        regime_used = "GLOBAL_FALLBACK"
-    else:
-        regime_used = str(current_regime)
-
-    for sl in SL_GRID:
-        for rr in RR_GRID:
-            vals = []
-            for i in regime_indices:
-                r = barrier_result(df, atr_s, i, side, sl, rr)
-                if r is not None:
-                    vals.append(r-2*(fee+slip)/100)
-            if len(vals) >= 35:
-                a = np.asarray(vals)
-                downside = np.sqrt(np.mean(np.minimum(a, 0)**2))
-                score = a.mean()-0.35*downside
-                results.append((score, sl, rr, len(a), a.mean(), (a > 0).mean()))
-    if not results:
-        return 1.5, 2.0, None, [], regime_used
-    results.sort(reverse=True)
-    return float(results[0][1]), float(results[0][2]), results[0], results[:10], regime_used
-
-
-def evaluate_oos(df, atr_s, X, y, regime_s, train_end, k, sl, rr, fee, slip):
-    # Model fit only on pre-OOS data; all test observations are later in time.
-    model = pipe(k)
-    model.fit(X.iloc[:train_end], y.iloc[:train_end])
-    test_start = train_end+HORIZON
-    test_end = len(X)-HORIZON
-    if test_end <= test_start+20:
-        return [], None, None, []
-    pred = model.predict(X.iloc[test_start:test_end])
-    actual = y.iloc[test_start:test_end].to_numpy()
-    bacc = balanced_accuracy_score(actual, pred)
-    acc = accuracy_score(actual, pred)
-    trades, details = [], []
-    for off, p in enumerate(pred):
-        if int(p) not in (-1, 1):
-            continue
-        i = test_start+off
-        raw = barrier_result(df, atr_s, i, int(p), sl, rr)
-        if raw is None:
-            continue
-        r = trade_r_multiple(raw, float(df.Close.iloc[i]), float(atr_s.iloc[i]),
-                             sl, fee, slip)
-        trades.append(float(r))
-        details.append((df.index[i], int(p), float(r), regime_s.iloc[i]))
-    return trades, float(bacc), float(acc), details
-
-
-def risk_path_mc(r_multiples, base_risk_pct, simulations=1000, n_trades=100):
-    # Bootstrap in R units. Equity sizing compounds and risk cuts after drawdown.
-    if len(r_multiples) < 10:
-        return None
-    rng = np.random.default_rng(20261103)
-    samples = rng.choice(np.asarray(r_multiples), size=(simulations, n_trades), replace=True)
-    finals, maxdds, ruin = [], [], []
-    for seq in samples:
-        eq, peak, mdd = 1.0, 1.0, 0.0
-        for r in seq:
-            dd = eq/peak-1
-            risk = base_risk_pct/100
-            if dd <= -0.20:
-                risk *= 0.20
-            elif dd <= -0.15:
-                risk *= 0.35
-            elif dd <= -0.10:
-                risk *= 0.50
-            elif dd <= -0.06:
-                risk *= 0.75
-            # Cap one-trade loss at 1R; profit remains proportional to R.
-            r_limited = max(float(r), -1.0)
-            eq *= max(0.01, 1 + risk*r_limited)
-            peak = max(peak, eq)
-            mdd = min(mdd, eq/peak-1)
-        finals.append(eq-1)
-        maxdds.append(mdd)
-        ruin.append(eq < 0.5)
-    return {
-        "median": float(np.median(finals)),
-        "p05": float(np.percentile(finals, 5)),
-        "p95": float(np.percentile(finals, 95)),
-        "dd95": float(np.percentile(maxdds, 5)),
-        "ruin": float(np.mean(ruin))
-    }
-
-
-def adaptive_risk(min_risk, max_risk, bacc, agreement, expectancy_r, n_trades, drawdown):
-    # Explicit deterministic policy. Not represented as reinforcement learning.
-    quality = np.clip((bacc-0.33)/0.20, 0, 1) if bacc is not None else 0
-    agree = np.clip((agreement-0.33)/0.50, 0, 1)
-    edge = np.clip(expectancy_r/0.30, 0, 1)
-    sample = np.clip(n_trades/40, 0, 1)
-    score = 0.30*quality+0.25*agree+0.30*edge+0.15*sample
-    risk = min_risk+(max_risk-min_risk)*score
-    if drawdown <= -0.20:
-        risk = min_risk
-    elif drawdown <= -0.15:
-        risk = min_risk+(risk-min_risk)*0.20
-    elif drawdown <= -0.10:
-        risk = min_risk+(risk-min_risk)*0.40
-    elif drawdown <= -0.06:
-        risk = min_risk+(risk-min_risk)*0.70
-    return float(np.clip(risk, min_risk, max_risk)), float(score)
-
-
-def run_engine(period, equity, min_risk, max_risk, max_leverage, fee, slip, train_window):
-    try:
-        df = get_btc(period)
-        if len(df) < 450:
-            raise ValueError("En az 450 günlük mum gerekli.")
-        # Exclude current possibly incomplete daily candle.
-        df = df.iloc[:-1].copy()
-        X_all, atr_all = make_features(df)
-        y_all, _ = make_target(df, atr_all)
-        regimes_all = regime_labels(X_all)
-
-        # Align rows and purge final horizon whose labels are not mature.
-        valid = X_all.notna().all(axis=1) & y_all.notna()
-        X = X_all.loc[valid].iloc[:-HORIZON].copy()
-        y = y_all.loc[X.index].astype(int).copy()
-        dfv = df.loc[X.index].copy()
-        atrv = atr_all.loc[X.index].copy()
-        regv = regimes_all.loc[X.index].copy()
-        if len(X) < 300:
-            raise ValueError("Temiz özelliklerden sonra yeterli veri kalmadı.")
-
-        # Reserve untouched final OOS block.
-        oos_n = min(180, max(75, int(len(X)*0.22)))
-        dev_end = len(X)-oos_n-HORIZON
-        if dev_end < 200:
-            raise ValueError("OOS ayrımı için yeterli geliştirme verisi yok.")
-
-        dev_X, dev_y = X.iloc[:dev_end], y.iloc[:dev_end]
-        if len(dev_X) > int(train_window):
-            dev_X, dev_y = dev_X.iloc[-int(train_window):], dev_y.iloc[-int(train_window):]
-            # Keep aligned development frame and indices.
-            dev_start_idx = X.index.get_loc(dev_X.index[0])
-        else:
-            dev_start_idx = 0
-
-        best_k, k_scores = tune_k(dev_X, dev_y)
-        # Calibration split is chronological and separate from fit subset.
-        cal_n = min(120, max(45, int(len(dev_X)*0.20)))
-        fit_end = len(dev_X)-cal_n-HORIZON
-        if fit_end <= 100:
-            raise ValueError("Kalibrasyon için eğitim verisi yetersiz.")
-        fit_X, fit_y = dev_X.iloc[:fit_end], dev_y.iloc[:fit_end]
-        cal_X, cal_y = dev_X.iloc[fit_end+HORIZON:], dev_y.iloc[fit_end+HORIZON:]
-        cal_model = pipe(best_k)
-        cal_model.fit(fit_X, fit_y)
-        raw_cal = cal_model.predict_proba(cal_X)
-        calibrated_cal = calibrate_probabilities(
-            raw_cal, cal_model.named_steps["knn"].classes_, cal_y.to_numpy()
-        )
-        # Current prediction from the same pre-calibration fit model.
-        current_x = X_all.iloc[[-1]]
-        raw_current = cal_model.predict_proba(current_x)[0:1]
-        # Fit isotonic calibrators on held-out calibration predictions.
-        calibrated_current = np.zeros((1, len(CLASSES)))
-        for j, cls in enumerate(CLASSES):
-            classes_now = list(cal_model.named_steps["knn"].classes_)
-            if cls not in classes_now:
-                continue
-            col = raw_cal[:, classes_now.index(cls)]
-            truth = (cal_y.to_numpy() == cls).astype(int)
-            raw_val = raw_current[:, classes_now.index(cls)]
-            if len(truth) >= 35 and len(np.unique(truth)) == 2:
-                iso = IsotonicRegression(out_of_bounds="clip")
-                iso.fit(col, truth)
-                calibrated_current[0, j] = iso.predict(raw_val)[0]
-            else:
-                calibrated_current[0, j] = raw_val[0]
-        if calibrated_current.sum() > 0:
-            calibrated_current /= calibrated_current.sum()
-        else:
-            calibrated_current[0] = [1/3, 1/3, 1/3]
-        pmap = {cls: float(calibrated_current[0, j]) for j, cls in enumerate(CLASSES)}
-        p_down, p_flat, p_up = pmap[-1], pmap[0], pmap[1]
-        side = 1 if p_up >= p_down else -1
-
-        # Neighbor agreement based on fit examples only.
-        imp, scaler = cal_model.named_steps["imputer"], cal_model.named_steps["scale"]
-        zfit = scaler.transform(imp.transform(fit_X))
-        zcur = scaler.transform(imp.transform(current_x))
-        nn = NearestNeighbors(n_neighbors=best_k).fit(zfit)
-        _, idx = nn.kneighbors(zcur)
-        agreement = float((fit_y.iloc[idx[0]].to_numpy() == side).mean())
-
-        # Optimize barriers on development data only, filtered to the current regime.
-        current_regime = str(regimes_all.iloc[-1])
-        dev_idx = dev_X.index
-        dev_df = df.loc[dev_idx]
-        dev_atr = atr_all.loc[dev_idx]
-        dev_reg = regimes_all.loc[dev_idx]
-        sl, rr, opt, top, regime_used = optimize_barriers(
-            dev_df, dev_atr, dev_reg, len(dev_df), side,
-            float(fee), float(slip), current_regime
-        )
-        regime_note = (
-            f"TP/SL optimizasyon rejimi: {regime_used}. "
-            "Yeterli rejim örneği yoksa tüm geliştirme dönemine geri dönülür."
-        )
-
-        # OOS evaluation on untouched tail. Purge gap separates train and test.
-        oos_X = X.iloc[dev_end+HORIZON:]
-        oos_y = y.iloc[dev_end+HORIZON:]
-        oos_df = df.loc[oos_X.index]
-        oos_atr = atr_all.loc[oos_X.index]
-        oos_reg = regimes_all.loc[oos_X.index]
-        oos_model = pipe(best_k)
-        oos_model.fit(dev_X, dev_y)
-        oos_pred = oos_model.predict(oos_X)
-        oos_bacc = balanced_accuracy_score(oos_y, oos_pred)
-        oos_acc = accuracy_score(oos_y, oos_pred)
-        r_values, oos_details = [], []
-        for i, pred in enumerate(oos_pred):
-            if int(pred) not in (-1, 1):
-                continue
-            raw_ret = barrier_result(oos_df, oos_atr, i, int(pred), sl, rr)
-            if raw_ret is None:
-                continue
-            r = trade_r_multiple(raw_ret, float(oos_df.Close.iloc[i]),
-                                 float(oos_atr.iloc[i]), sl, float(fee), float(slip))
-            r_values.append(r)
-            oos_details.append((oos_df.index[i], int(pred), r, str(oos_reg.iloc[i])))
-
-        expectancy_r = float(np.mean(r_values)) if r_values else 0.0
-        recent = df.Close.tail(30)
-        drawdown = float(recent.iloc[-1]/recent.cummax().iloc[-1]-1)
-        risk_pct, risk_score = adaptive_risk(
-            float(min_risk), float(max_risk), float(oos_bacc),
-            agreement, expectancy_r, len(r_values), drawdown
-        )
-        mc = risk_path_mc(r_values, risk_pct) if r_values else None
-
-        entry = float(df.Close.iloc[-1])
-        current_atr = float(atr_all.iloc[-1])
-        stop_d, target_d = sl*current_atr, sl*current_atr*rr
-        stop = entry-stop_d if side == 1 else entry+stop_d
-        target = entry+target_d if side == 1 else entry-target_d
-
-        # Position size: include estimated round-trip costs in risk per BTC.
-        risk_cash = float(equity)*risk_pct/100
-        cost_per_btc = stop_d+entry*2*(float(fee)+float(slip))/100
-        btc_qty = risk_cash/cost_per_btc if cost_per_btc > 0 else 0
-        notional = btc_qty*entry
-        max_notional = float(equity)*float(max_leverage)
-        capped = notional > max_notional
-        if capped:
-            btc_qty = max_notional/entry
-            notional = btc_qty*entry
-        actual_risk_cash = btc_qty*cost_per_btc
-        margin = notional/max(float(max_leverage), 1)
-
-        # Strong no-trade gate based on untouched OOS results.
-        trade_ok = (
-            max(p_up, p_down) >= 0.43
-            and abs(p_up-p_down) >= 0.12
-            and agreement >= 0.55
-            and oos_bacc >= 0.36
-            and len(r_values) >= 15
-            and expectancy_r > 0
-            and p_flat < 0.60
-        )
-        if not trade_ok:
-            signal = "WAIT — İŞLEM AÇMA"
-            btc_qty = notional = margin = actual_risk_cash = 0.0
-        else:
-            signal = "LONG" if side == 1 else "SHORT"
-
-        mc_text = (
-            f"100 işlem · 1.000 bootstrap senaryosu · medyan: {mc['median']:.2%} · "
-            f"%5 kötü sonuç: {mc['p05']:.2%} · %5 kuyruk max DD: {mc['dd95']:.2%} · "
-            f"%50 sermaye altına inme frekansı: {mc['ruin']:.1%}"
-            if mc else "Monte Carlo için yeterli OOS işlem yok."
-        )
-        k_text = " | ".join([f"K={k}: {s:.3f}" for s, k in sorted(k_scores, reverse=True)])
-        report = f"""
-# {signal}
-
-**Son kapanmış mum:** {df.index[-1].date()} · **Referans fiyat:** ${entry:,.2f}
-
-## Kalibre edilmiş KNN
-| Ölçüm | Değer |
-|---|---:|
-| P(UP) | {p_up:.1%} |
-| P(FLAT) | {p_flat:.1%} |
-| P(DOWN) | {p_down:.1%} |
-| Seçilen K | {best_k} |
-| Komşu yön uyumu | {agreement:.1%} |
-| OOS balanced accuracy | {oos_bacc:.3f} |
-| OOS accuracy | {oos_acc:.3f} |
-| OOS işlem sayısı | {len(r_values)} |
-| OOS expectancy | {expectancy_r:.3f}R / işlem |
-| Güncel rejim | {current_regime} |
-
-**K seçim skorları:** {k_text}
-
-## TP / SL
-| Parametre | Değer |
-|---|---:|
-| SL | {sl:.2f} ATR |
-| TP | {rr:.2f}R |
-| Stop-loss | ${stop:,.2f} |
-| Take-profit | ${target:,.2f} |
-| ATR(14) | ${current_atr:,.2f} |
-
-{regime_note}
-
-## Gerçek risk-bütçeli pozisyon
-| Parametre | Değer |
-|---|---:|
-| Hesap büyüklüğü | ${equity:,.2f} |
-| Adaptif risk | {risk_pct:.3f}% |
-| Risk bütçesi | ${risk_cash:,.2f} |
-| BTC miktarı | {btc_qty:.8f} |
-| Nominal pozisyon | ${notional:,.2f} |
-| Tahmini teminat | ${margin:,.2f} |
-| Tahmini stop kaybı + maliyet | ${actual_risk_cash:,.2f} |
-| Kaldıraç sınırı | {"Uygulandı" if capped else "Uygulanmadı"} |
-| Son 30 günlük kapanı�� DD | {drawdown:.2%} |
-
-## Monte Carlo — R-multiple + gerçek risk yüzdesi
-{mc_text}
-"""
-        fig = go.Figure([go.Candlestick(
-            x=df.index[-150:], open=df.Open.tail(150), high=df.High.tail(150),
-            low=df.Low.tail(150), close=df.Close.tail(150), name="BTCUSD"
-        )])
-        if trade_ok:
-            fig.add_hline(y=stop, line_dash="dash", annotation_text="SL")
-            fig.add_hline(y=target, line_dash="dash", annotation_text="TP")
-        fig.update_layout(title="BTCUSD Daily — last 150 candles", height=520,
-                          xaxis_rangeslider_visible=False)
-
-        top_df = pd.DataFrame(top, columns=[
-            "score", "SL_ATR", "TP_R", "samples", "mean_net_return", "win_rate"
-        ])
-        if not top_df.empty:
-            top_df["score"] = top_df.score.map(lambda x: f"{x:.5f}")
-            top_df["mean_net_return"] = top_df.mean_net_return.map(lambda x: f"{x:.3%}")
-            top_df["win_rate"] = top_df.win_rate.map(lambda x: f"{x:.1%}")
-
-        disclaimer = (
-            "**Araştırma prototipi; otomatik emir göndermez.** KNN olasılık kalibrasyonu "
-            "tek bir tarihsel kalibrasyon dilimine dayanır ve küçük örneklerde ham olasılığa "
-            "geri döner. TP/SL optimizasyonu geliştirme döneminde yapılır; son dönem OOS "
-            "olarak ayrılır. Rejim etiketleri geliştirme verisinin volatilite kantillerine "
-            "dayanır; bu nedenle canlı dağılım değişebilir. Monte Carlo, OOS R-multiple "
-            "serisini bootstrap eder ve işlem başına gerçek risk yüzdesini bileşik uygular; "
-            "bağımsızlık varsayımı seri korelasyonunu ve rejim değişimini tam modellemez. "
-            "Pozisyon hesabı BTC spot miktarı varsayar; CFD lot sözleşmesi, spread, funding, "
-            "swap, komisyon, minimum lot, marjin ve broker fiyatı farklı olabilir. Gap ve "
-            "kayma kaybı planlanan riskin üstüne çıkarabilir. Canlı hesap öncesi paper trading "
-            "ve broker bazlı doğrulama zorunludur."
-        )
-        return report, fig, top_df, disclaimer
-
-    except Exception as exc:
-        return f"# Hata\n{type(exc).__name__}: {exc}", None, pd.DataFrame(), \
-               "Veri bağlantısını ve parametreleri kontrol edin."
-
-
-with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "# GOSHAWK — Adaptive BTCUSD Risk Engine v3\n"
-        "Kalibre edilmiş KNN · adaptif K · TP/SL optimizasyonu · bağımsız OOS · "
-        "R-multiple Monte Carlo · drawdown bazlı risk."
-    )
-    with gr.Row():
-        with gr.Column():
-            period = gr.Dropdown(["2y", "5y", "max"], value="5y", label="Veri geçmişi")
-            train_window = gr.Slider(300, 1500, value=900, step=50, label="Maksimum eğitim penceresi")
-            equity = gr.Number(value=10000, label="Hesap büyüklüğü (USD)")
-            max_leverage = gr.Slider(1, 10, value=3, step=1, label="Azami kaldıraç")
-        with gr.Column():
-            min_risk = gr.Slider(0.05, 0.5, value=0.10, step=0.05, label="Minimum risk (%)")
-            max_risk = gr.Slider(0.25, 1.5, value=0.75, step=0.05, label="Maksimum risk (%)")
-            fee = gr.Number(value=0.05, label="Tek yön komisyon (%)")
-            slip = gr.Number(value=0.03, label="Tek yön slippage (%)")
-    run = gr.Button("Öğren, optimize et ve test et", variant="primary")
-    output = gr.Markdown()
-    chart = gr.Plot()
-    optimization = gr.Dataframe(label="En iyi TP/SL kombinasyonları", interactive=False)
-    disclaimer = gr.Markdown()
-    run.click(run_engine,
-              inputs=[period, equity, min_risk, max_risk, max_leverage, fee, slip, train_window],
-              outputs=[output, chart, optimization, disclaimer])
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)