Upload app.py

app.py

@@ -0,0 +1,575 @@
+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)