Upload app.py

app.py

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