Upload app.py

app.py

@@ -0,0 +1,329 @@
+# app.py
+# BTC/USD Multi-Model AI Radar: 7 ML models + Groq explanation
+# Gradio app for Hugging Face Spaces.
+# Required packages: gradio, pandas, numpy, scikit-learn, xgboost, groq
+
+import os
+import warnings
+import numpy as np
+import pandas as pd
+import gradio as gr
+
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.impute import SimpleImputer
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.ensemble import (
+    RandomForestClassifier,
+    ExtraTreesClassifier,
+    HistGradientBoostingClassifier,
+    GradientBoostingClassifier,
+    VotingClassifier,
+)
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score, balanced_accuracy_score, log_loss
+from sklearn.model_selection import TimeSeriesSplit
+from xgboost import XGBClassifier
+
+try:
+    from groq import Groq
+except Exception:
+    Groq = None
+
+warnings.filterwarnings("ignore")
+CSV_PATH = os.environ.get("BTC_CSV_PATH", "BTCUSD_M30.csv")
+HORIZON = 1
+MIN_ROWS = 120
+
+api_key = os.environ.get("GROQ_API_KEY")
+client = Groq(api_key=api_key) if (api_key and Groq) else None
+
+
+def load_local_csv(path=CSV_PATH):
+    """Reads headerless or headed OHLCV CSV/TSV."""
+    if not os.path.exists(path):
+        return None, f"CSV bulunamadı: {path}"
+
+    try:
+        # Try common separators and both header formats.
+        raw = None
+        for sep in ("\t", ",", ";"):
+            for header in (None, 0):
+                try:
+                    candidate = pd.read_csv(path, sep=sep, header=header)
+                    if candidate.shape[1] >= 6:
+                        raw = candidate
+                        break
+                except Exception:
+                    pass
+            if raw is not None:
+                break
+
+        if raw is None or raw.shape[1] < 6:
+            return None, "CSV en az 6 sütun içermeli: date, open, high, low, close, volume."
+
+        raw = raw.iloc[:, :6].copy()
+        raw.columns = ["date", "open", "high", "low", "close", "volume"]
+
+        # If the first row was actually a header, remove it after numeric conversion.
+        for col in ["open", "high", "low", "close", "volume"]:
+            raw[col] = pd.to_numeric(raw[col], errors="coerce")
+
+        raw["date"] = raw["date"].astype(str)
+        raw = raw.dropna(subset=["open", "high", "low", "close", "volume"])
+        raw = raw[(raw["close"] > 0) & (raw["high"] > 0) & (raw["low"] > 0)]
+        raw = raw.sort_values("date").drop_duplicates("date").reset_index(drop=True)
+
+        if len(raw) < MIN_ROWS:
+            return None, f"En az {MIN_ROWS} geçerli mum gerekli; bulunan: {len(raw)}."
+        return raw, None
+    except Exception as exc:
+        return None, f"CSV okuma hatası: {exc}"
+
+
+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 make_features(raw):
+    d = raw.copy()
+    close = d["close"]
+    d["ret_1"] = close.pct_change()
+    d["ret_2"] = close.pct_change(2)
+    d["ret_3"] = close.pct_change(3)
+    d["ret_6"] = close.pct_change(6)
+    d["ret_12"] = close.pct_change(12)
+    d["range_pct"] = (d["high"] - d["low"]) / close
+    d["body_pct"] = (d["close"] - d["open"]) / d["open"]
+    d["upper_wick"] = (d["high"] - d[["open", "close"]].max(axis=1)) / close
+    d["lower_wick"] = (d[["open", "close"]].min(axis=1) - d["low"]) / close
+
+    for window in (5, 10, 20, 50):
+        ma = close.rolling(window).mean()
+        d[f"ma_gap_{window}"] = close / ma - 1
+        d[f"volatility_{window}"] = d["ret_1"].rolling(window).std()
+
+    d["rsi_14"] = rsi(close, 14)
+    ema12 = close.ewm(span=12, adjust=False).mean()
+    ema26 = close.ewm(span=26, adjust=False).mean()
+    d["macd_pct"] = (ema12 - ema26) / close
+    d["macd_signal_pct"] = (d["macd_pct"].ewm(span=9, adjust=False).mean())
+    d["volume_change"] = d["volume"].pct_change()
+    d["volume_z20"] = (
+        (d["volume"] - d["volume"].rolling(20).mean()) /
+        d["volume"].rolling(20).std()
+    )
+    d["target"] = (close.shift(-HORIZON) > close).astype(int)
+    # Last row has no known future label; exclude it from training.
+    d = d.iloc[:-HORIZON].replace([np.inf, -np.inf], np.nan)
+    feature_cols = [
+        c for c in d.columns
+        if c not in ["date", "open", "high", "low", "close", "volume", "target"]
+    ]
+    d = d.dropna(subset=feature_cols + ["target"]).reset_index(drop=True)
+    return d, feature_cols
+
+
+def build_models():
+    # Seven independent classifiers. Scaling is included where distance/margin
+    # methods need it; tree models use the original feature scale.
+    return {
+        "XGBoost": XGBClassifier(
+            n_estimators=180, max_depth=3, learning_rate=0.035,
+            subsample=0.85, colsample_bytree=0.85, reg_lambda=2,
+            objective="binary:logistic", eval_metric="logloss",
+            random_state=42, n_jobs=-1
+        ),
+        "KNN": Pipeline([
+            ("imputer", SimpleImputer(strategy="median")),
+            ("scaler", StandardScaler()),
+            ("model", KNeighborsClassifier(n_neighbors=9, weights="distance"))
+        ]),
+        "Random Forest": RandomForestClassifier(
+            n_estimators=220, max_depth=7, min_samples_leaf=4,
+            class_weight="balanced_subsample", random_state=42, n_jobs=-1
+        ),
+        "Extra Trees": ExtraTreesClassifier(
+            n_estimators=220, max_depth=8, min_samples_leaf=4,
+            class_weight="balanced", random_state=43, n_jobs=-1
+        ),
+        "Hist Gradient Boosting": HistGradientBoostingClassifier(
+            max_iter=160, learning_rate=0.05, max_leaf_nodes=15,
+            l2_regularization=1.0, random_state=44
+        ),
+        "Logistic Regression": Pipeline([
+            ("imputer", SimpleImputer(strategy="median")),
+            ("scaler", StandardScaler()),
+            ("model", LogisticRegression(C=0.5, max_iter=1500, class_weight="balanced"))
+        ]),
+        "SVM": Pipeline([
+            ("imputer", SimpleImputer(strategy="median")),
+            ("scaler", StandardScaler()),
+            ("model", SVC(C=1.0, kernel="rbf", probability=True,
+                          class_weight="balanced", random_state=45))
+        ]),
+    }
+
+
+def fit_and_evaluate(data, features):
+    X = data[features].astype(float)
+    y = data["target"].astype(int)
+
+    # Chronological holdout: no random shuffle and no future-to-past leakage.
+    split = max(int(len(data) * 0.8), 50)
+    split = min(split, len(data) - 20)
+    X_train, X_test = X.iloc[:split], X.iloc[split:]
+    y_train, y_test = y.iloc[:split], y.iloc[split:]
+
+    models = build_models()
+    trained = {}
+    results = {}
+    latest_x = X.iloc[[-1]]
+
+    for name, model in models.items():
+        try:
+            model.fit(X_train, y_train)
+            trained[name] = model
+            prob = model.predict_proba(X_test)[:, 1]
+            latest_prob = float(model.predict_proba(latest_x)[0, 1])
+            pred = (prob >= 0.5).astype(int)
+            results[name] = {
+                "up": latest_prob,
+                "accuracy": accuracy_score(y_test, pred) * 100,
+                "balanced": balanced_accuracy_score(y_test, pred) * 100,
+                "logloss": log_loss(y_test, np.clip(prob, 1e-6, 1 - 1e-6)),
+                "test_n": len(y_test),
+            }
+        except Exception as exc:
+            results[name] = {"error": str(exc)}
+
+    valid = {k: v for k, v in results.items() if "up" in v}
+    if len(valid) < 2:
+        raise RuntimeError("Ensemble için en az iki model başarıyla eğitilemedi.")
+
+    # Equal-weight ensemble keeps a weak/overfit holdout score from dominating.
+    ensemble_up = float(np.mean([v["up"] for v in valid.values()]))
+    return trained, results, ensemble_up, len(X_train), len(X_test)
+
+
+def groq_comment(prompt):
+    if not client:
+        return "Groq açıklaması için GROQ_API_KEY gerekli. Model tahminleri yine çalışır."
+    try:
+        response = client.chat.completions.create(
+            model=os.environ.get("GROQ_MODEL", "openai/gpt-oss-120b"),
+            messages=[
+                {"role": "system", "content": "Türkçe konuşan, temkinli bir nicel piyasa analistisin. Kesinlik veya kâr garantisi verme. Verilmeyen veri uydurma."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.25,
+            max_tokens=1100
+        )
+        return response.choices[0].message.content
+    except Exception as exc:
+        return f"Groq API hatası: {exc}"
+
+
+def analyze():
+    raw, error = load_local_csv()
+    if error:
+        return error, {}, pd.DataFrame()
+
+    try:
+        data, features = make_features(raw)
+        if len(data) < MIN_ROWS - 35:
+            return f"Göstergelerden sonra veri yetersiz: {len(data)} satır.", {}, pd.DataFrame()
+
+        trained, results, ensemble_up, train_n, test_n = fit_and_evaluate(data, features)
+        ensemble_down = 1 - ensemble_up
+        direction = "YUKARI 📈" if ensemble_up >= 0.5 else "AŞAĞI 📉"
+        confidence = max(ensemble_up, ensemble_down) * 100
+
+        rows = []
+        valid_probs = []
+        for name, item in results.items():
+            if "up" in item:
+                valid_probs.append(item["up"])
+                rows.append([
+                    name, f"{item['up'] * 100:.1f}%",
+                    f"{item['accuracy']:.1f}%",
+                    f"{item['balanced']:.1f}%",
+                    f"{item['logloss']:.4f}", item["test_n"]
+                ])
+            else:
+                rows.append([name, "Hata", "-", "-", item["error"][:80], "-"])
+
+        last = raw.iloc[-1]
+        model_table = pd.DataFrame(
+            rows,
+            columns=["Model", "Yükseliş olasılığı", "Test doğruluğu",
+                     "Dengeli doğruluk", "Log-loss / hata", "Test mum"]
+        )
+
+        prompt = f"""
+BTC/USD M30 analizini Türkçe hazırla.
+Son kapanış: {float(last['close']):.2f} USD
+Son tarih: {last['date']}
+Ensemble yükseliş olasılığı: %{ensemble_up*100:.1f}
+Ensemble düşüş olasılığı: %{ensemble_down*100:.1f}
+Yön: {direction}; yön güveni (olasılık): %{confidence:.1f}
+Eğitim mum sayısı: {train_n}; kronolojik test mum sayısı: {test_n}.
+Model sonuçları:
+{model_table.to_string(index=False)}
+Başlıklar:
+1. Çoklu model değerlendirmesi ve modeller arası uzlaşma/ayrışma
+2. Teknik görünüm
+3. Yukarı ve aşağı senaryolar
+4. Risk yönetimi ve belirsizlik
+İşlem fiyatı, stop veya hedef seviyesi uydurma; OHLC verisinden hesaplanmayan seviyeleri açıkça belirt.
+Test doğruluğunun gelecekteki başarı garantisi olmadığını belirt. Yatırım tavsiyesi değildir.
+"""
+        ai_text = groq_comment(prompt)
+        header = (
+            f"## BTC/USD Çoklu Model Radarı\n\n"
+            f"**Son kapanış:** ${float(last['close']):,.2f}  |  "
+            f"**Tarih:** {last['date']}\n\n"
+            f"**Ensemble:** {direction}  |  **Yükseliş:** %{ensemble_up*100:.1f}  |  "
+            f"**Düşüş:** %{ensemble_down*100:.1f}\n\n"
+            f"**Aktif model:** {len(valid_probs)}/7  |  "
+            f"**Eğitim:** {train_n} mum  |  **Test:** {test_n} mum\n\n"
+            f"> Olasılık/güven skoru başarı oranı değildir. Test sonuçları geçmiş veriye aittir.\n\n"
+            f"---\n\n{ai_text}"
+        )
+        labels = {
+            name: float(item["up"])
+            for name, item in results.items() if "up" in item
+        }
+        labels["Ensemble"] = ensemble_up
+        return header, labels, model_table
+    except Exception as exc:
+        return f"Analiz hatası: {exc}", {}, pd.DataFrame()
+
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange", secondary_hue="slate")) as demo:
+    gr.Markdown(
+        f"""# ₿ BTC/USD Multi-Model AI Radar
+**Veri:** `{CSV_PATH}` · **Zaman dilimi:** M30 · **Model sayısı:** 7 ML modeli + Groq AI açıklaması
+
+CSV biçimi: `date, open, high, low, close, volume` (başlıklı/başlıksız CSV veya TSV).
+"""
+    )
+    with gr.Row():
+        run_btn = gr.Button("📊 CSV'yi Oku ve 7 Modeli Eğit", variant="primary", size="lg")
+    prediction = gr.Label(label="Model yükseliş olasılıkları")
+    report = gr.Markdown("Analizi başlatmak için butona basın.")
+    table = gr.Dataframe(label="Model karşılaştırması — kronolojik holdout testi",
+                         interactive=False, wrap=True)
+    run_btn.click(fn=analyze, inputs=[], outputs=[report, prediction, table])
+    gr.Markdown(
+        "**Not:** Modeller aynı CSV üzerinde eğitilir. Test bölümü kronolojik olarak ayrılır; "
+        "bu bir canlı emir/broker bağlantısı değildir. Geçmiş test performansı geleceği garanti etmez."
+    )
+
+if __name__ == "__main__":
+    demo.launch()