Delete app.py

app.py

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