Delete app.py

app.py

@@ -1,354 +0,0 @@
-import warnings
-warnings.filterwarnings("ignore")
-
-from datetime import datetime, timezone
-import numpy as np
-import pandas as pd
-import yfinance as yf
-import gradio as gr
-import plotly.graph_objects as go
-
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
-from sklearn.impute import SimpleImputer
-from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors
-from sklearn.metrics import accuracy_score, balanced_accuracy_score, confusion_matrix
-
-APP_TITLE = "BTCUSD KNN Daily Risk Engine"
-
-def rsi(series, period=14):
-    delta = series.diff()
-    gain = delta.clip(lower=0).ewm(alpha=1 / period, adjust=False).mean()
-    loss = (-delta.clip(upper=0)).ewm(alpha=1 / period, adjust=False).mean()
-    rs = gain / loss.replace(0, np.nan)
-    return 100 - (100 / (1 + rs))
-
-def atr(df, period=14):
-    prev_close = df["Close"].shift(1)
-    tr = pd.concat([
-        df["High"] - df["Low"],
-        (df["High"] - prev_close).abs(),
-        (df["Low"] - prev_close).abs()
-    ], axis=1).max(axis=1)
-    return tr.ewm(alpha=1 / period, adjust=False).mean()
-
-def download_data(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 veri döndürmedi. Daha sonra tekrar deneyin.")
-    if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.get_level_values(0)
-    needed = ["Open", "High", "Low", "Close", "Volume"]
-    df = df[needed].copy().dropna()
-    df.index = pd.to_datetime(df.index)
-    return df
-
-def make_features(df):
-    x = pd.DataFrame(index=df.index)
-    close = df["Close"]
-    ret = close.pct_change()
-    for n in [1, 2, 3, 5, 10, 20]:
-        x[f"ret_{n}"] = close.pct_change(n)
-    x["rsi_14"] = rsi(close, 14) / 100.0
-    a = atr(df, 14)
-    x["atr_pct"] = a / close
-    x["range_pct"] = (df["High"] - df["Low"]) / close
-    x["body_pct"] = (df["Close"] - df["Open"]) / df["Open"]
-    for n in [5, 10, 20, 50]:
-        ema = close.ewm(span=n, adjust=False).mean()
-        x[f"ema_gap_{n}"] = close / ema - 1
-    ema12 = close.ewm(span=12, adjust=False).mean()
-    ema26 = close.ewm(span=26, adjust=False).mean()
-    macd = ema12 - ema26
-    signal = macd.ewm(span=9, adjust=False).mean()
-    x["macd_hist_pct"] = (macd - signal) / close
-    x["volatility_10"] = ret.rolling(10).std()
-    x["volatility_20"] = ret.rolling(20).std()
-    vol_mean = df["Volume"].rolling(20).mean()
-    vol_std = df["Volume"].rolling(20).std()
-    x["volume_z20"] = (df["Volume"] - vol_mean) / vol_std.replace(0, np.nan)
-    x["volume_change"] = df["Volume"].pct_change()
-    return x.replace([np.inf, -np.inf], np.nan), a
-
-def build_model(k):
-    return Pipeline([
-        ("imputer", SimpleImputer(strategy="median")),
-        ("scaler", StandardScaler()),
-        ("knn", KNeighborsClassifier(
-            n_neighbors=k, weights="distance", metric="minkowski", p=2
-        ))
-    ])
-
-def fmt_pct(v):
-    return f"{v * 100:.2f}%"
-
-def run_engine(period, k, train_window, threshold_atr, atr_stop,
-               reward_risk, equity, risk_pct, max_leverage,
-               contract_size, fee_pct, slippage_pct, use_latest):
-    try:
-        df = download_data(period)
-        if len(df) < 180:
-            raise ValueError("Yeterli günlük veri yok. En az 180 mum gerekli.")
-
-        # Yahoo'nun son günlük mumu henüz kapanmamış olabilir.
-        if not use_latest and len(df) > 2:
-            df = df.iloc[:-1].copy()
-
-        X, atr_series = make_features(df)
-        next_ret = df["Close"].shift(-1) / df["Close"] - 1
-        next_atr_pct = atr_series / df["Close"]
-        band = threshold_atr * next_atr_pct
-
-        # Üç sınıf: -1 aşağı, 0 nötr, +1 yukarı.
-        y = pd.Series(
-            np.where(next_ret > band, 1, np.where(next_ret < -band, -1, 0)),
-            index=df.index
-        )
-
-        data = X.copy()
-        data["target"] = y
-        data["future_return"] = next_ret
-        data = data.replace([np.inf, -np.inf], np.nan)
-        feature_cols = list(X.columns)
-
-        # Son satırın ileriye dönük hedefi bilinmez; yalnızca eğitimden çıkarılır.
-        trainable = data.dropna(subset=["target", "future_return"])
-        trainable = trainable.dropna(subset=feature_cols, how="all")
-        if len(trainable) < max(100, int(k) + 30):
-            raise ValueError("KNN eğitimi için yeterli temiz örnek bulunamadı.")
-
-        # Son kapanmış mumun özellikleriyle tahmin.
-        current_x = X.iloc[[-1]]
-        if current_x.isna().all(axis=1).iloc[0]:
-            raise ValueError("Son mum için özellik üretilemedi.")
-
-        window = min(int(train_window), len(trainable))
-        train = trainable.iloc[-window:]
-        if len(train) <= int(k):
-            raise ValueError("Komşu sayısı eğitim örneklerinden küçük olmalı.")
-
-        model = build_model(int(k))
-        model.fit(train[feature_cols], train["target"].astype(int))
-        probs = model.predict_proba(current_x[feature_cols])[0]
-        classes = model.named_steps["knn"].classes_
-        prob_map = {int(c): float(p) for c, p in zip(classes, probs)}
-        p_down = prob_map.get(-1, 0.0)
-        p_flat = prob_map.get(0, 0.0)
-        p_up = prob_map.get(1, 0.0)
-
-        # Yakın geçmiş örnekleri: aynı özellik uzayında en yakın K gözlem.
-        transformed_train = model.named_steps["scaler"].transform(
-            model.named_steps["imputer"].transform(train[feature_cols])
-        )
-        transformed_now = model.named_steps["scaler"].transform(
-            model.named_steps["imputer"].transform(current_x[feature_cols])
-        )
-        nn = NearestNeighbors(n_neighbors=int(k), metric="euclidean")
-        nn.fit(transformed_train)
-        distances, indices = nn.kneighbors(transformed_now)
-        neighbors = train.iloc[indices[0]].copy()
-        neighbors["distance"] = distances[0]
-        mean_neighbor_return = float(neighbors["future_return"].mean())
-        median_neighbor_return = float(neighbors["future_return"].median())
-
-        # Chronological holdout sanity check: train on past, test on later samples.
-        eval_n = min(120, max(30, len(trainable) // 5))
-        if len(trainable) > eval_n + 100:
-            hist_train = trainable.iloc[:-eval_n]
-            hist_test = trainable.iloc[-eval_n:]
-            eval_model = build_model(int(k))
-            eval_model.fit(hist_train[feature_cols], hist_train["target"].astype(int))
-            pred = eval_model.predict(hist_test[feature_cols])
-            acc = accuracy_score(hist_test["target"].astype(int), pred)
-            bacc = balanced_accuracy_score(hist_test["target"].astype(int), pred)
-            eval_text = (
-                f"Son {eval_n} örneklik kronolojik holdout — "
-                f"Accuracy: {acc:.3f} | Balanced accuracy: {bacc:.3f}. "
-                "Bu sonuç gelecekteki performans garantisi değildir."
-            )
-        else:
-            eval_text = "Holdout değerlendirmesi için yeterli geçmiş örnek yok."
-
-        entry = float(df["Close"].iloc[-1])
-        current_atr = float(atr_series.iloc[-1])
-        if not np.isfinite(current_atr) or current_atr <= 0:
-            raise ValueError("ATR hesaplanamadı.")
-
-        # Basit karar filtresi; nötr sınıf yüksekse işlem açma.
-        if p_up > p_down and p_up >= 0.45 and p_flat < 0.55:
-            side = "LONG"
-            stop = entry - atr_stop * current_atr
-            target = entry + reward_risk * (entry - stop)
-            confidence = p_up
-        elif p_down > p_up and p_down >= 0.45 and p_flat < 0.55:
-            side = "SHORT"
-            stop = entry + atr_stop * current_atr
-            target = entry - reward_risk * (stop - entry)
-            confidence = p_down
-        else:
-            side = "WAIT / NO TRADE"
-            stop = np.nan
-            target = np.nan
-            confidence = max(p_up, p_down)
-
-        risk_cash = float(equity) * float(risk_pct) / 100.0
-        stop_distance = abs(entry - stop) if np.isfinite(stop) else np.nan
-
-        # fee_pct ve slippage_pct her yön için varsayılır; yaklaşık round-trip maliyet.
-        round_trip_cost_rate = 2 * (float(fee_pct) + float(slippage_pct)) / 100.0
-        if side != "WAIT / NO TRADE":
-            stop_pct = stop_distance / entry
-            cost_per_btc = stop_distance + entry * round_trip_cost_rate
-            btc_qty = risk_cash / cost_per_btc if cost_per_btc > 0 else 0.0
-            notional = btc_qty * entry
-            leverage_used = notional / float(equity) if equity > 0 else np.nan
-            if leverage_used > float(max_leverage):
-                btc_qty = (float(equity) * float(max_leverage)) / entry
-                notional = btc_qty * entry
-                effective_risk = btc_qty * cost_per_btc
-                sizing_note = (
-                    f"Kaldıraç sınırı nedeniyle miktar kısıldı. "
-                    f"Gerçekleşen yaklaşık stop riski: {effective_risk:.2f} "
-                    f"({effective_risk / equity * 100:.2f}%)."
-                )
-            else:
-                effective_risk = btc_qty * cost_per_btc
-                sizing_note = "Pozisyon miktarı risk bütçesine göre hesaplandı."
-            lots = btc_qty / float(contract_size)
-            margin_est = notional / float(max_leverage)
-        else:
-            btc_qty = notional = lots = margin_est = 0.0
-            effective_risk = 0.0
-            sizing_note = "Model filtresi yeterli yönsel avantaj bulamadı; işlem açma."
-
-        # Fiyat grafiği ve ATR seviyeleri.
-        plot_df = df.tail(120)
-        fig = go.Figure()
-        fig.add_trace(go.Candlestick(
-            x=plot_df.index, open=plot_df["Open"], high=plot_df["High"],
-            low=plot_df["Low"], close=plot_df["Close"], name="BTC-USD"
-        ))
-        if np.isfinite(stop):
-            fig.add_hline(y=stop, line_dash="dash", annotation_text="Stop")
-            fig.add_hline(y=target, line_dash="dash", annotation_text="Take profit")
-        fig.update_layout(
-            title="BTC-USD — Daily candles (last 120)",
-            xaxis_title="Date", yaxis_title="USD",
-            height=520, xaxis_rangeslider_visible=False
-        )
-
-        neighbor_view = neighbors[["target", "future_return", "distance"]].copy()
-        neighbor_view["target"] = neighbor_view["target"].map(
-            {-1: "DOWN", 0: "FLAT", 1: "UP"}
-        )
-        neighbor_view["future_return"] = neighbor_view["future_return"].map(fmt_pct)
-        neighbor_view["distance"] = neighbor_view["distance"].map(lambda z: f"{z:.3f}")
-        neighbor_view.index = neighbor_view.index.strftime("%Y-%m-%d")
-        neighbor_view = neighbor_view.reset_index().rename(columns={
-            "index": "Neighbor date", "target": "Historical class",
-            "future_return": "Next-day return", "distance": "Distance"
-        })
-
-        report = f"""
-## {side}
-
-**Son kullanılan mum:** {df.index[-1].date()}  
-**Kapanış / referans giriş:** ${entry:,.2f}
-
-### KNN sınıf olasılıkları
-- Yukarı: **{p_up:.1%}**
-- Nötr: **{p_flat:.1%}**
-- Aşağı: **{p_down:.1%}**
-- Seçilen yönün olasılığı: **{confidence:.1%}**
-
-### Plan seviyeleri
-- Stop-loss: **{('$' + format(stop, ',.2f')) if np.isfinite(stop) else '—'}**
-- Take-profit: **{('$' + format(target, ',.2f')) if np.isfinite(target) else '—'}**
-- ATR(14): **${current_atr:,.2f}**
-- Planlanan R:R: **1 : {reward_risk:.2f}**
-
-### Pozisyon boyutu
-- Hesap özsermayesi: **${equity:,.2f}**
-- Risk bütçesi: **${risk_cash:,.2f} ({risk_pct:.2f}%)**
-- Tahmini BTC miktarı: **{btc_qty:.6f} BTC**
-- Tahmini lot: **{lots:.6f} lot** (1 lot = {contract_size} BTC)
-- Nominal pozisyon: **${notional:,.2f}**
-- Tahmini teminat (@ max leverage): **${margin_est:,.2f}**
-- Tahmini stop riski + maliyet: **${effective_risk:,.2f}**
-- {sizing_note}
-
-### Komşu örnekler
-- En yakın K örneğin ortalama ertesi gün getirisi: **{fmt_pct(mean_neighbor_return)}**
-- Medyan ertesi gün getirisi: **{fmt_pct(median_neighbor_return)}**
-
-### Model kontrolü
-{eval_text}
-"""
-
-        notes = (
-            "Önemli: Bu bir araştırma/prototip karar destek aracıdır; yatırım tavsiyesi veya "
-            "kârlılık garantisi değildir. KNN olasılıkları kalibre edilmiş gerçek olasılıklar "
-            "olarak yorumlanmamalıdır. Günlük BTC-USD verisi Yahoo Finance'tan gelir; "
-            "broker CFD fiyatı, spread, swap, funding, minimum lot, lot sözleşmesi ve "
-            "marjin kuralları farklı olabilir. Emir vermeden önce broker şartlarıyla "
-            "miktarı yeniden doğrulayın. Stop emirlerinde gap/slippage nedeniyle kayıp "
-            "hesaplanandan yüksek olabilir. SHORT işlemlerde ayrıca borçlanma/funding "
-            "maliyetleri bulunabilir."
-        )
-        return report, fig, neighbor_view, notes
-
-    except Exception as e:
-        return f"## Hata\n{type(e).__name__}: {e}", None, pd.DataFrame(), (
-            "Veri bağlantısını, parametreleri ve internet erişimini kontrol edin."
-        )
-
-with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "# BTCUSD KNN — 1 Günlük Risk & Pozisyon Motoru\n"
-        "KNN benzer geçmiş günleri kullanarak yön sınıfı tahmini üretir; ATR tabanlı "
-        "SL/TP ve risk bütçesine göre BTC miktarı hesaplar."
-    )
-    with gr.Row():
-        with gr.Column(scale=1):
-            period = gr.Dropdown(
-                ["2y", "5y", "max"], value="5y", label="Geçmiş veri aralığı"
-            )
-            k = gr.Slider(3, 31, value=9, step=2,
-                          label="K komşu sayısı")
-            train_window = gr.Slider(200, 1500, value=750, step=50,
-                                     label="Eğitim penceresi (gün)")
-            threshold_atr = gr.Slider(0.0, 1.0, value=0.25, step=0.05,
-                                      label="Sınıf eşiği (ATR oranı)")
-            atr_stop = gr.Slider(0.5, 5.0, value=2.0, step=0.1,
-                                 label="Stop mesafesi (ATR)")
-            reward_risk = gr.Slider(0.5, 5.0, value=2.0, step=0.1,
-                                    label="Risk / ödül oranı")
-            use_latest = gr.Checkbox(
-                value=False, label="Son günlük mumu kullan (kapanmamış olabilir)"
-            )
-        with gr.Column(scale=1):
-            equity = gr.Number(value=10000, label="Hesap özsermayesi (USD)")
-            risk_pct = gr.Slider(0.1, 3.0, value=0.5, step=0.1,
-                                 label="İşlem başına risk (%)")
-            max_leverage = gr.Slider(1, 20, value=3, step=1,
-                                     label="Azami kaldıraç (pozisyon limiti)")
-            contract_size = gr.Number(value=1.0, label="1 lot kaç BTC?")
-            fee_pct = gr.Number(value=0.05, label="Tek yön komisyon (%)")
-            slippage_pct = gr.Number(value=0.03, label="Tek yön kayma varsayımı (%)")
-            run = gr.Button("Analiz et", variant="primary")
-
-    result = gr.Markdown()
-    chart = gr.Plot(label="BTCUSD fiyat ve risk seviyeleri")
-    neighbors = gr.Dataframe(label="KNN en yakın geçmiş örnekleri", interactive=False)
-    disclaimer = gr.Markdown()
-    run.click(
-        fn=run_engine,
-        inputs=[period, k, train_window, threshold_atr, atr_stop, reward_risk,
-                equity, risk_pct, max_leverage, contract_size, fee_pct,
-                slippage_pct, use_latest],
-        outputs=[result, chart, neighbors, disclaimer]
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)