Upload app.py

app.py

@@ -0,0 +1,457 @@
+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
+from sklearn.metrics import balanced_accuracy_score, accuracy_score
+
+APP_TITLE = "Goshawk Adaptive BTCUSD Research Engine"
+HORIZON = 5
+K_CANDIDATES = [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]
+
+
+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]:
+        ema = c.ewm(span=n, adjust=False).mean()
+        x[f"ema_gap_{n}"] = c/ema - 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["volatility_10"] = daily_ret.rolling(10).std()
+    x["volatility_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 make_target(df, atr, horizon=HORIZON, threshold=0.20):
+    future_ret = df.Close.shift(-horizon)/df.Close - 1
+    band = threshold*(atr/df.Close)*np.sqrt(horizon)
+    target = np.where(future_ret > band, 1,
+             np.where(future_ret < -band, -1, 0))
+    return pd.Series(target, index=df.index), future_ret
+
+
+def model_pipe(k):
+    return Pipeline([
+        ("imputer", SimpleImputer(strategy="median")),
+        ("scaler", StandardScaler()),
+        ("knn", __import__("sklearn").neighbors.KNeighborsClassifier(
+            n_neighbors=int(k), weights="distance", metric="minkowski", p=2
+        ))
+    ])
+
+
+def tune_k(X, y, candidates=K_CANDIDATES):
+    # Chronological inner split; labels are already forward-looking, so purge horizon.
+    split = int(len(X)*0.80)
+    tr_end = max(50, split-HORIZON)
+    xtr, ytr = X.iloc[:tr_end], y.iloc[:tr_end]
+    xva, yva = X.iloc[split:], y.iloc[split:]
+    scores = []
+    for k in candidates:
+        if len(xtr) <= k or len(xva) < 20:
+            continue
+        m = model_pipe(k)
+        m.fit(xtr, ytr.astype(int))
+        pred = m.predict(xva)
+        scores.append((balanced_accuracy_score(yva.astype(int), pred), k))
+    if not scores:
+        return 9, []
+    scores.sort(reverse=True)
+    return int(scores[0][1]), scores
+
+
+def barrier_trade(df, i, side, sl_atr, rr, atr_values, horizon=HORIZON):
+    entry = float(df.Close.iloc[i])
+    av = float(atr_values.iloc[i])
+    if not np.isfinite(av) or av <= 0:
+        return None
+    stop_dist = sl_atr*av
+    target_dist = stop_dist*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_dist, hi >= entry+target_dist
+        else:
+            sl_hit, tp_hit = hi >= entry+stop_dist, lo <= entry-target_dist
+        # Daily OHLC cannot reveal which barrier came first: assume the adverse one.
+        if sl_hit and tp_hit:
+            return -sl_atr*av/entry
+        if sl_hit:
+            return -sl_atr*av/entry
+        if tp_hit:
+            return target_dist/entry
+    exit_price = float(df.Close.iloc[end])
+    return side*(exit_price-entry)/entry
+
+
+def optimize_barriers(df, atr_values, end_index, side, fee_pct, slip_pct):
+    # Optimize only on the pre-validation segment; validation is kept separate.
+    start = max(70, end_index-600)
+    cost = 2*(fee_pct+slip_pct)/100
+    best, rows = None, []
+    for sl in SL_GRID:
+        for rr in RR_GRID:
+            results = []
+            for i in range(start, end_index-HORIZON):
+                r = barrier_trade(df, i, side, sl, rr, atr_values)
+                if r is not None:
+                    results.append(r-cost)
+            if len(results) < 35:
+                continue
+            a = np.asarray(results)
+            # Conservative objective: mean return penalized by dispersion.
+            score = a.mean() - 0.25*a.std()
+            rows.append((score, sl, rr, len(a), a.mean(), (a > 0).mean()))
+    if not rows:
+        return 1.5, 2.0, None, []
+    rows.sort(reverse=True)
+    best = rows[0]
+    return float(best[1]), float(best[2]), best, rows[:10]
+
+
+def evaluate_oos(df, atr_values, X, y, train_end, sl, rr, fee_pct, slip_pct, k):
+    # Fit strictly before validation, then predict the later validation segment.
+    model = model_pipe(k)
+    model.fit(X.iloc[:train_end], y.iloc[:train_end].astype(int))
+    test_start = train_end + HORIZON
+    test_end = len(X)-HORIZON
+    if test_end <= test_start+10:
+        return [], None, None
+    preds = model.predict(X.iloc[test_start:test_end])
+    actual = y.iloc[test_start:test_end].astype(int).to_numpy()
+    bacc = balanced_accuracy_score(actual, preds)
+    trades = []
+    cost = 2*(fee_pct+slip_pct)/100
+    for offset, pred in enumerate(preds):
+        i = test_start+offset
+        if pred not in (-1, 1):
+            continue
+        result = barrier_trade(df, i, int(pred), sl, rr, atr_values)
+        if result is not None:
+            trades.append(result-cost)
+    return trades, bacc, accuracy_score(actual, preds)
+
+
+def monte_carlo(trades, simulations=500, horizon=100):
+    if len(trades) < 10:
+        return None
+    rng = np.random.default_rng(42)
+    arr = np.asarray(trades, dtype=float)
+    finals, max_dds = [], []
+    for _ in range(simulations):
+        sample = rng.choice(arr, size=horizon, replace=True)
+        equity = np.cumprod(1+sample)
+        peak = np.maximum.accumulate(np.r_[1.0, equity])[1:]
+        dd = equity/peak-1
+        finals.append(equity[-1]-1)
+        max_dds.append(float(dd.min()))
+    return {
+        "median": float(np.median(finals)),
+        "p05": float(np.percentile(finals, 5)),
+        "p95": float(np.percentile(finals, 95)),
+        "dd95": float(np.percentile(max_dds, 5))
+    }
+
+
+def adaptive_risk(min_risk, max_risk, bacc, agreement, drawdown, expectancy, n_trades):
+    # Transparent conservative policy, not a trained RL agent.
+    quality = np.clip((bacc-0.33)/0.17, 0, 1)
+    neighbor = np.clip((agreement-0.33)/0.50, 0, 1)
+    edge = np.clip(expectancy/0.01, 0, 1) if np.isfinite(expectancy) else 0
+    sample = np.clip(n_trades/40, 0, 1)
+    score = 0.35*quality + 0.25*neighbor + 0.25*edge + 0.15*sample
+    risk = min_risk + (max_risk-min_risk)*score
+    if drawdown <= -0.15:
+        risk *= 0.25
+    elif drawdown <= -0.10:
+        risk *= 0.40
+    elif drawdown <= -0.06:
+        risk *= 0.65
+    return float(np.clip(risk, min_risk, max_risk)), float(score)
+
+
+def run_engine(period, equity, min_risk, max_risk, max_leverage,
+               fee_pct, slip_pct, train_window):
+    try:
+        df = get_btc(period)
+        if len(df) < 400:
+            raise ValueError("En az 400 günlük mum gerekli.")
+        # Avoid using a possibly incomplete current daily candle.
+        df = df.iloc[:-1].copy()
+        X, atr_values = make_features(df)
+        y, forward_returns = make_target(df, atr_values)
+        data = X.copy()
+        data["target"] = y
+        valid_mask = data.notna().all(axis=1) & data.target.notna()
+        valid_idx = data.index[valid_mask]
+        Xv = X.loc[valid_idx].copy()
+        yv = y.loc[valid_idx].astype(int).copy()
+        # Last HORIZON rows are not eligible as labels for training.
+        Xv, yv = Xv.iloc[:-HORIZON], yv.iloc[:-HORIZON]
+        if len(Xv) < 250:
+            raise ValueError("Özelliklerden sonra yeterli eğitim örneği kalmadı.")
+
+        # Reserve a final chronological OOS block.
+        oos_n = min(150, max(60, int(len(Xv)*0.20)))
+        development_end = len(Xv)-oos_n-HORIZON
+        if development_end < 180:
+            raise ValueError("Walk-forward için veri yetersiz.")
+        dev_X, dev_y = Xv.iloc[:development_end], yv.iloc[:development_end]
+        if len(dev_X) > int(train_window):
+            dev_X, dev_y = dev_X.iloc[-int(train_window):], dev_y.iloc[-int(train_window):]
+
+        best_k, k_scores = tune_k(dev_X, dev_y)
+        # KNN's K is selected on an inner chronological validation split.
+        # Fit the final development model for the current signal.
+        current_x = X.iloc[[-1]]
+        current_model = model_pipe(best_k)
+        current_model.fit(dev_X, dev_y)
+        probs = current_model.predict_proba(current_x)
+        classes = current_model.named_steps["knn"].classes_
+        pmap = {int(c): float(p) for c, p in zip(classes, probs[0])}
+        p_up, p_flat, p_down = pmap.get(1, 0), pmap.get(0, 0), pmap.get(-1, 0)
+        side = 1 if p_up >= p_down else -1
+
+        # Neighbor agreement from the fitted KNN's own training set.
+        imp = current_model.named_steps["imputer"]
+        scaler = current_model.named_steps["scaler"]
+        ztr = scaler.transform(imp.transform(dev_X))
+        znow = scaler.transform(imp.transform(current_x))
+        from sklearn.neighbors import NearestNeighbors
+        nn = NearestNeighbors(n_neighbors=best_k).fit(ztr)
+        _, ix = nn.kneighbors(znow)
+        agreement = float((dev_y.iloc[ix[0]].to_numpy() == side).mean())
+
+        # Optimize TP/SL on development data only; final OOS is not used in selection.
+        dev_df_end = development_end
+        aligned_df = df.loc[Xv.index]
+        aligned_atr = atr_values.loc[Xv.index]
+        # Use the development block for barrier optimization.
+        sl, rr, opt, top_rows = optimize_barriers(
+            aligned_df.iloc[:dev_df_end], aligned_atr.iloc[:dev_df_end],
+            dev_df_end, side, float(fee_pct), float(slip_pct)
+        )
+
+        # Independent untouched OOS evaluation.
+        oos_df = aligned_df.iloc[:]
+        oos_atr = aligned_atr
+        oos_trades, oos_bacc, oos_acc = evaluate_oos(
+            oos_df, oos_atr, Xv, yv, development_end,
+            sl, rr, float(fee_pct), float(slip_pct), best_k
+        )
+        mc = monte_carlo(oos_trades)
+        expectancy = float(np.mean(oos_trades)) if oos_trades 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 if oos_bacc is not None else 0.33),
+            agreement, drawdown, expectancy, len(oos_trades)
+        )
+
+        entry = float(df.Close.iloc[-1])
+        current_atr = float(atr_values.iloc[-1])
+        stop_dist = sl*current_atr
+        target_dist = stop_dist*rr
+        stop = entry-stop_dist if side == 1 else entry+stop_dist
+        target = entry+target_dist if side == 1 else entry-target_dist
+
+        # Trade gate is deliberately conservative.
+        trade_ok = (
+            max(p_up, p_down) >= 0.43
+            and abs(p_up-p_down) >= 0.12
+            and agreement >= 0.55
+            and oos_bacc is not None and oos_bacc >= 0.36
+            and len(oos_trades) >= 15
+            and expectancy > 0
+            and p_flat < 0.60
+        )
+
+        risk_cash = float(equity)*risk_pct/100
+        cost_rate = 2*(float(fee_pct)+float(slip_pct))/100
+        per_btc_risk = stop_dist + entry*cost_rate
+        btc_qty = risk_cash/per_btc_risk if per_btc_risk > 0 else 0
+        max_notional = float(equity)*float(max_leverage)
+        notional = btc_qty*entry
+        capped = notional > max_notional
+        if capped:
+            btc_qty = max_notional/entry
+            notional = btc_qty*entry
+        actual_risk = btc_qty*per_btc_risk
+        margin = notional/max(float(max_leverage), 1)
+        if not trade_ok:
+            signal = "WAIT — OOS KANITI YETERSİZ"
+            btc_qty = notional = actual_risk = margin = 0.0
+        else:
+            signal = "LONG" if side == 1 else "SHORT"
+
+        k_text = " · ".join([f"K={kk}: {ss:.3f}" for ss, kk in sorted(k_scores, reverse=True)])
+        mc_text = (
+            f"100 işlem bootstrap medyan: {mc['median']:.1%} · "
+            f"%5 kötü senaryo: {mc['p05']:.1%} · "
+            f"%5 kuyruk max DD: {mc['dd95']:.1%}"
+            if mc else "Monte Carlo için en az 10 OOS işlem gerekli."
+        )
+        report = f"""
+# {signal}
+
+**Son kapanmış günlük mum:** {df.index[-1].date()} · **Referans fiyat:** ${entry:,.2f}
+
+## Otomatik öğrenme
+| Metrik | Sonuç |
+|---|---:|
+| P(LONG) | {p_up:.1%} |
+| P(FLAT) | {p_flat:.1%} |
+| P(SHORT) | {p_down:.1%} |
+| Seçilen K | {best_k} |
+| Komşu yön uyumu | {agreement:.1%} |
+| OOS balanced accuracy | {oos_bacc if oos_bacc is not None else float('nan'):.3f} |
+| OOS accuracy | {oos_acc if oos_acc is not None else float('nan'):.3f} |
+| OOS işlem sayısı | {len(oos_trades)} |
+| OOS expectancy / işlem | {expectancy:.3%} |
+| Piyasa rejimi | {('Yüksek' if X.iloc[-1].volatility_20 > 0.045 else 'Düşük' if X.iloc[-1].volatility_20 < 0.018 else 'Orta')} volatilite |
+
+**K optimizasyonu:** {k_text}
+
+## Bağımsız TP / SL optimizasyonu
+| Parametre | Değer |
+|---|---:|
+| SL mesafesi | {sl:.2f} ATR |
+| TP mesafesi | {rr:.2f}R |
+| Stop-loss | ${stop:,.2f} |
+| Take-profit | ${target:,.2f} |
+| ATR(14) | ${current_atr:,.2f} |
+
+## Adaptif risk ve pozisyon
+| Parametre | Değer |
+|---|---:|
+| Hesap büyüklüğü | ${equity:,.2f} |
+| Model risk skoru | {risk_score:.2f} |
+| Dinamik risk | {risk_pct:.2f}% |
+| Risk bütçesi | ${risk_cash:,.2f} |
+| BTC miktarı | {btc_qty:.6f} |
+| Nominal pozisyon | ${notional:,.2f} |
+| Tahmini teminat | ${margin:,.2f} |
+| Tahmini stop kaybı + maliyet | ${actual_risk:,.2f} |
+| Kaldıraç sınırı uygulandı | {"Evet" if capped else "Hayır"} |
+| Son 30 günlük kapanış DD | {drawdown:.2%} |
+
+## Monte Carlo — OOS işlem sonuçları
+{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 = pd.DataFrame(top_rows, columns=[
+            "score", "SL_ATR", "RR", "samples", "mean_net_return", "win_rate"
+        ])
+        if not top.empty:
+            top["mean_net_return"] = top.mean_net_return.map(lambda v: f"{v:.3%}")
+            top["win_rate"] = top.win_rate.map(lambda v: f"{v:.1%}")
+            top["score"] = top.score.map(lambda v: f"{v:.5f}")
+        disclaimer = (
+            "**Önemli:** Araştırma prototipidir; otomatik emir göndermez ve kâr garantisi vermez. "
+            "K seçimi, TP/SL seçimi ve nihai OOS ayrımı kronolojik yapılır; yine de tekrar "
+            "denemeler ve veri sağlayıcı farkları overfitting yaratabilir. OOS sonuçları "
+            "tek başına canlı performans kanıtı değildir. Monte Carlo geçmiş OOS işlemlerini "
+            "bootstrap eder; rejim değişimini garantiyle modellemez. BTC-USD spot verisi "
+            "broker CFD fiyatı değildir. Spread, swap, funding, komisyon, lot sözleşmesi, "
+            "marjin ve minimum miktarı broker şartlarına göre ayrıca doğrulayın. Stop emirleri "
+            "gap/slippage nedeniyle hesaplanan riskten daha fazla kaybettirebilir. Bu sürüm "
+            "online learning veya gerçek RL ajanı değildir; her çalıştırmada yeniden eğitim "
+            "ve şeffaf adaptif risk kuralı kullanır."
+        )
+        return report, fig, top, disclaimer
+
+    except Exception as e:
+        return f"# Hata\n{type(e).__name__}: {e}", 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 KNN BTCUSD Research Engine\n"
+        "K otomatik seçimi · TP/SL optimizasyonu · ayrı kronolojik OOS test · "
+        "adaptif risk · Monte Carlo."
+    )
+    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_pct = gr.Number(value=0.05, label="Tek yön komisyon (%)")
+            slip_pct = 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_pct, slip_pct, train_window],
+        outputs=[output, chart, optimization, disclaimer]
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)