Upload app.py

app.py

@@ -0,0 +1,382 @@
+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.metrics import balanced_accuracy_score
+
+APP_TITLE = "Goshawk Adaptive BTCUSD Engine"
+HORIZON = 5
+FEE_DEFAULT = 0.05
+SLIPPAGE_DEFAULT = 0.03
+
+
+def download_btc(period="5y"):
+    df = yf.download("BTC-USD", period=period, interval="1d",
+                     auto_adjust=True, progress=False)
+    if df is None or df.empty:
+        raise ValueError("BTC verisi alınamadı. İnternet/veri sağlayıcısını kontrol edin.")
+    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 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 feature_engineering(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"return_{n}"] = c.pct_change(n)
+    for n in [5, 10, 20, 50]:
+        ema = c.ewm(span=n, adjust=False).mean()
+        x[f"ema_distance_{n}"] = c/ema - 1
+    x["rsi"] = rsi(c)/100
+    atr = calc_atr(df)
+    x["atr_pct"] = atr/c
+    x["range_pct"] = (df.High-df.Low)/c
+    x["body_pct"] = (df.Close-df.Open)/df.Open
+    x["volatility_10"] = c.pct_change().rolling(10).std()
+    x["volatility_20"] = c.pct_change().rolling(20).std()
+    x["volume_z"] = (v-v.rolling(20).mean())/v.rolling(20).std().replace(0, np.nan)
+    x["volume_return"] = 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), atr
+
+
+def make_labels(df, atr, horizon=HORIZON, threshold=0.20):
+    # Label is based only on the close-to-close forward return; features are lagged/current.
+    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 build_pipeline(k):
+    return Pipeline([
+        ("imputer", SimpleImputer(strategy="median")),
+        ("scale", StandardScaler()),
+        ("knn", KNeighborsClassifier(n_neighbors=k, weights="distance"))
+    ])
+
+
+def barrier_outcome(df, start_i, side, stop_atr, target_atr, horizon=HORIZON):
+    entry = float(df.Close.iloc[start_i])
+    atr = float(calc_atr(df).iloc[start_i])
+    if not np.isfinite(atr) or atr <= 0:
+        return None
+    if side == 1:
+        stop, target = entry-stop_atr*atr, entry+target_atr*atr
+    else:
+        stop, target = entry+stop_atr*atr, entry-target_atr*atr
+    end = min(start_i+horizon, len(df)-1)
+    for j in range(start_i+1, end+1):
+        hi, lo = float(df.High.iloc[j]), float(df.Low.iloc[j])
+        if side == 1:
+            hit_sl, hit_tp = lo <= stop, hi >= target
+        else:
+            hit_sl, hit_tp = hi >= stop, lo <= target
+        # Conservative assumption if both barriers are touched in one daily candle.
+        if hit_sl and hit_tp:
+            return -stop_atr*atr/entry
+        if hit_sl:
+            return -stop_atr*atr/entry
+        if hit_tp:
+            return target_atr*atr/entry
+    final = float(df.Close.iloc[end])
+    return side*(final-entry)/entry
+
+
+def optimize_barriers(df, train_end, side, fee_pct, slip_pct):
+    # Select SL/TP from matured historical examples only.
+    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]
+    first = max(60, train_end-450)
+    candidates = []
+    cost = 2*(fee_pct+slip_pct)/100
+    for sl in sl_grid:
+        for rr in rr_grid:
+            outcomes = []
+            for i in range(first, train_end):
+                # Only use examples whose full forward horizon is inside training history.
+                if i+HORIZON >= train_end:
+                    continue
+                r = barrier_outcome(df, i, side, sl, sl*rr)
+                if r is not None:
+                    outcomes.append(r-cost)
+            if len(outcomes) < 35:
+                continue
+            arr = np.asarray(outcomes)
+            # Penalize unstable settings; maximize average net return per trade.
+            score = arr.mean() - 0.25*arr.std()/np.sqrt(len(arr))
+            candidates.append((score, sl, rr, len(arr), arr.mean(), (arr > 0).mean()))
+    if not candidates:
+        return 1.5, 2.0, None
+    best = max(candidates, key=lambda z: z[0])
+    return best[1], best[2], best
+
+
+def regime_name(row):
+    if row["volatility_20"] > 0.045:
+        vol = "Yüksek volatilite"
+    elif row["volatility_20"] < 0.018:
+        vol = "Düşük volatilite"
+    else:
+        vol = "Orta volatilite"
+    if row["ema_distance_20"] > 0.025:
+        trend = "Yukarı trend"
+    elif row["ema_distance_20"] < -0.025:
+        trend = "Aşağı trend"
+    else:
+        trend = "Yatay / kararsız"
+    return f"{trend} · {vol}"
+
+
+def run_engine(period, equity, max_risk, min_risk, max_leverage,
+               fee_pct, slip_pct, train_window, k):
+    try:
+        df = download_btc(period)
+        if len(df) < 300:
+            raise ValueError("En az 300 günlük mum gerekli.")
+        # Ignore today's unfinished daily candle by default.
+        df = df.iloc[:-1].copy()
+        X, atr = feature_engineering(df)
+        y, fwd = make_labels(df, atr)
+        data = X.copy()
+        data["target"] = y
+        data["future"] = fwd
+        valid = data.dropna(subset=["target", "future"])
+        valid = valid.dropna(subset=list(X.columns), how="all")
+        if len(valid) < 180:
+            raise ValueError("Model eğitimi için yeterli temiz örnek yok.")
+
+        # Latest known candle's feature row; training labels are already matured.
+        current_x = X.iloc[[-1]]
+        train_end = len(valid)
+        window = min(int(train_window), train_end-HORIZON-1)
+        train = valid.iloc[-window:]
+        if len(train) <= int(k):
+            raise ValueError("K komşu sayısı eğitim örneklerinden küçük.")
+
+        model = build_pipeline(int(k))
+        model.fit(train[X.columns], train.target.astype(int))
+        probs = model.predict_proba(current_x[X.columns])[0]
+        classes = model.named_steps["knn"].classes_
+        p = {int(c): float(v) for c, v in zip(classes, probs)}
+        p_long, p_short, p_flat = p.get(1, 0), p.get(-1, 0), p.get(0, 0)
+        direction = 1 if p_long >= p_short else -1
+        direction_prob = max(p_long, p_short)
+        edge = abs(p_long-p_short)
+
+        # KNN neighborhood agreement and chronological holdout score.
+        imputer, scaler = model.named_steps["imputer"], model.named_steps["scale"]
+        z_train = scaler.transform(imputer.transform(train[X.columns]))
+        z_now = scaler.transform(imputer.transform(current_x[X.columns]))
+        nn = NearestNeighbors(n_neighbors=int(k)).fit(z_train)
+        distances, indices = nn.kneighbors(z_now)
+        analogs = train.iloc[indices[0]]
+        agreement = float((analogs.target.astype(int) == direction).mean())
+
+        test_n = min(90, max(30, len(valid)//6))
+        hist_train = valid.iloc[:-test_n]
+        hist_test = valid.iloc[-test_n:]
+        eval_model = build_pipeline(int(k))
+        eval_model.fit(hist_train[X.columns], hist_train.target.astype(int))
+        pred = eval_model.predict(hist_test[X.columns])
+        holdout_bacc = balanced_accuracy_score(hist_test.target.astype(int), pred)
+
+        sl_mult, rr_mult, opt_stats = optimize_barriers(
+            df, len(df)-HORIZON, direction, float(fee_pct), float(slip_pct)
+        )
+        entry = float(df.Close.iloc[-1])
+        current_atr = float(atr.iloc[-1])
+        stop_dist = sl_mult*current_atr
+        tp_dist = stop_dist*rr_mult
+        if direction == 1:
+            stop, target = entry-stop_dist, entry+tp_dist
+        else:
+            stop, target = entry+stop_dist, entry-tp_dist
+
+        # Adaptive risk: base on model edge, neighbor agreement, validation quality,
+        # and current drawdown proxy (recent 30-day peak-to-trough close drawdown).
+        close = df.Close
+        recent = close.tail(30)
+        dd = float(recent.iloc[-1]/recent.cummax().iloc[-1]-1)
+        quality = np.clip((holdout_bacc-0.33)/0.20, 0, 1)
+        conviction = np.clip((direction_prob-0.34)/0.35, 0, 1)
+        neighbor_quality = np.clip((agreement-0.33)/0.50, 0, 1)
+        risk_factor = 0.20 + 0.35*quality + 0.25*conviction + 0.20*neighbor_quality
+        if dd < -0.12:
+            risk_factor *= 0.35
+        elif dd < -0.07:
+            risk_factor *= 0.60
+        risk_pct = float(min_risk) + (float(max_risk)-float(min_risk))*risk_factor
+        risk_pct = float(np.clip(risk_pct, min_risk, max_risk))
+
+        # No trade when evidence is weak or validation is poor.
+        trade_ok = (
+            direction_prob >= 0.43 and edge >= 0.12 and agreement >= 0.55
+            and holdout_bacc >= 0.36 and p_flat < 0.60
+        )
+        risk_cash = float(equity)*risk_pct/100
+        cost_rate = 2*(float(fee_pct)+float(slip_pct))/100
+        cost_per_btc = stop_dist + entry*cost_rate
+        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)
+        leverage_limited = notional > max_notional
+        if leverage_limited:
+            btc_qty = max_notional/entry
+            notional = btc_qty*entry
+        actual_risk = btc_qty*cost_per_btc
+        lot_size_btc = 1.0  # Change to broker's contract specification.
+        lots = btc_qty/lot_size_btc
+        margin = notional/max(float(max_leverage), 1)
+
+        if not trade_ok:
+            signal = "WAIT — İŞLEM AÇMA"
+            btc_qty = notional = lots = margin = actual_risk = 0.0
+        else:
+            signal = "LONG" if direction == 1 else "SHORT"
+
+        if opt_stats:
+            opt_text = (
+                f"Optimizasyon örnek sayısı: {opt_stats[3]} · "
+                f"Geçmiş ortalama net getiri/işlem: {opt_stats[4]*100:.3f}% · "
+                f"Geçmiş pozitif sonuç oranı: {opt_stats[5]*100:.1f}%"
+            )
+        else:
+            opt_text = "TP/SL optimizasyonu için yeterli olgunlaşmış örnek bulunamadı."
+
+        report = f"""
+# {signal}
+
+**Referans tarih:** {df.index[-1].date()} · **Referans fiyat:** ${entry:,.2f}
+
+## Modelin öğrendikleri
+| Ölçüm | Sonuç |
+|---|---:|
+| P(up) | {p_long:.1%} |
+| P(flat) | {p_flat:.1%} |
+| P(down) | {p_short:.1%} |
+| En yakın komşu uyumu | {agreement:.1%} |
+| Kronolojik holdout balanced accuracy | {holdout_bacc:.3f} |
+| Piyasa rejimi | {regime_name(X.iloc[-1])} |
+
+## Otomatik TP / SL
+| Parametre | Değer |
+|---|---:|
+| Stop mesafesi | {sl_mult:.2f} ATR |
+| Hedef mesafesi | {rr_mult:.2f}R |
+| Stop-loss | ${stop:,.2f} |
+| Take-profit | ${target:,.2f} |
+| ATR(14) | ${current_atr:,.2f} |
+| TP/SL geçmiş optimizasyonu | {opt_text} |
+
+## Adaptif pozisyon ve risk
+| Parametre | Değer |
+|---|---:|
+| Hesap büyüklüğü | ${equity:,.2f} |
+| Öğrenilmiş 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} |
+| Son 30 günlük kapanış DD | {dd:.2%} |
+| Kaldıraç sınırı uygulandı mı? | {"Evet" if leverage_limited else "Hayır"} |
+
+Risk yüzdesi model kalitesi, komşu uyumu ve yakın dönem drawdown'a göre seçildi.
+"""
+
+        fig = go.Figure(data=[go.Candlestick(
+            x=df.index[-120:], open=df.Open.tail(120), high=df.High.tail(120),
+            low=df.Low.tail(120), close=df.Close.tail(120), 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", height=520,
+                          xaxis_rangeslider_visible=False)
+
+        neighbor_table = analogs[["target", "future"]].copy()
+        neighbor_table["target"] = neighbor_table.target.map({-1:"DOWN",0:"FLAT",1:"UP"})
+        neighbor_table["future"] = neighbor_table.future.map(lambda z: f"{z:.2%}")
+        neighbor_table.index = neighbor_table.index.strftime("%Y-%m-%d")
+        neighbor_table = neighbor_table.reset_index().rename(
+            columns={"index":"Tarih","target":"Sınıf","future":"5 günlük getiri"}
+        )
+        disclaimer = (
+            "**Araştırma prototipi — otomatik emir göndermez.** Model her çalıştırmada "
+            "indirilen geçmiş veriyi yeniden eğitir; canlı öğrenme/online learning değildir. "
+            "TP/SL seçimi geçmiş örneklerde optimize edilir ve overfitting riski taşır. "
+            "KNN skorları kalibre edilmiş olasılık değildir. Günlük OHLC mumlarında aynı "
+            "gün TP ve SL birlikte görülürse muhafazakâr olarak SL varsayılır. Yahoo BTC-USD "
+            "verisi broker CFD fiyatı değildir. Lot büyüklüğü, komisyon, spread, funding, "
+            "swap, marjin ve minimum miktarı broker şartlarına göre doğrulayın. Gerçek "
+            "hesapta kullanmadan önce out-of-sample walk-forward, paper trading ve stres "
+            "testleri zorunludur."
+        )
+        return report, fig, neighbor_table, 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 app:
+    gr.Markdown(
+        "# GOSHAWK — Adaptive BTCUSD KNN Risk Engine\n"
+        "Günlük veride KNN yön tahmini, geçmiş bariyer sonuçlarından adaptif TP/SL "
+        "seçimi ve model kalitesine göre dinamik risk/pozisyon boyutlandırma."
+    )
+    with gr.Row():
+        with gr.Column():
+            period = gr.Dropdown(["2y", "5y", "max"], value="5y", label="Veri geçmişi")
+            train_window = gr.Slider(250, 1500, value=900, step=50, label="Eğitim penceresi")
+            k = gr.Slider(3, 31, value=9, step=2, label="KNN komşu sayısı")
+            equity = gr.Number(value=10000, label="Hesap büyüklüğü (USD)")
+        with gr.Column():
+            min_risk = gr.Slider(0.1, 0.5, value=0.1, step=0.05, label="Minimum risk (%)")
+            max_risk = gr.Slider(0.5, 2.0, value=0.75, step=0.05, label="Maksimum risk (%)")
+            max_leverage = gr.Slider(1, 10, value=3, step=1, label="Azami kaldıraç")
+            fee_pct = gr.Number(value=FEE_DEFAULT, label="Tek yön komisyon (%)")
+            slip_pct = gr.Number(value=SLIPPAGE_DEFAULT, label="Tek yön slippage (%)")
+    run = gr.Button("Veriyi öğren ve analiz et", variant="primary")
+    output = gr.Markdown()
+    chart = gr.Plot()
+    neighbors = gr.Dataframe(label="En yakın geçmiş piyasa örnekleri", interactive=False)
+    disclaimer = gr.Markdown()
+    run.click(
+        run_engine,
+        inputs=[period, equity, max_risk, min_risk, max_leverage,
+                fee_pct, slip_pct, train_window, k],
+        outputs=[output, chart, neighbors, disclaimer]
+    )
+
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860)