Delete app.py

app.py

@@ -1,382 +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.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)