Update app.py

app.py

@@ -95,27 +95,26 @@ os.makedirs(MODEL_DIR, exist_ok=True)
 MODEL_PATH = os.path.join(MODEL_DIR, "gos_hawk_model.pkl")
 
 MIN_TRAIN_SAMPLES = 150
-REQUEST_TIMEOUT = 60        # daha uzun timeout (saatlik veri için)
+REQUEST_TIMEOUT = 60
 MAX_RETRIES = 3
 RETRY_BACKOFF = 2
 
-# Saatlik veri (24 saatlik hedef için daha fazla nokta → güvenilir model)
 HISTORY_TIME_SCALE = 1
 
-# Hedef ölçeği: log getiri * 10000 = baz puan
 TARGET_SCALE = 10000.0
-
-# Tahmin clip (log getiri, ±%15)
 MAX_LOG_RETURN = 0.15
 MIN_LOG_RETURN = -0.15
-
-# Belirsizlik eşiği (log getiri)
 LOW_CONFIDENCE_THRESHOLD = 0.01
-
-# Zaman-tabanlı hedef toleransı (saat)
 TARGET_TOLERANCE_HOURS = 12
 
-# Hedef feature kolonları
+# DİP ALIM SİNYALİ PARAMETRELERİ
+DIP_RSI_MAX = 40.0                  # RSI bu değerin altındaysa "aşırı satım"
+DIP_PERCENTILE_MAX = 0.25           # 7 günlük aralıkta alt %25'te mi?
+DIP_MIN_VOLUME_RATIO = 1.0          # Hacim ortalamanın üstünde mi?
+DIP_MIN_PREDICTED_PCT = -1.0        # Model tahmini bu kadar negatiften fazla olmalı
+DIP_MAX_SPREAD_PCT = 0.15           # Spread / fiyat > %15 ise likit değil
+DIP_MIN_LIQUIDITY = "Orta"          # Düşük likidite = atla
+
 FEATURE_COLS = [
     "hour", "dayofweek", "is_weekend",
     "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
@@ -139,7 +138,7 @@ PRICE_LIKE_COLS = [
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
     headers = {
-        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.4 (public-api-client)",
+        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.6 (public-api-client)",
         "Accept": "application/json",
     }
     for attempt in range(MAX_RETRIES):
@@ -191,7 +190,7 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
 
 def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 1, qualities: str = "1") -> pd.DataFrame:
     all_records = []
-    chunk_size = 20  # saatlik veri daha ağır → daha küçük chunk
+    chunk_size = 20
     for i in range(0, len(item_ids), chunk_size):
         chunk = item_ids[i:i+chunk_size]
         url = f"{API_BASE}/stats/history/{','.join(chunk)}.json"
@@ -276,15 +275,6 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
 
 
 def build_features(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Saatlik veride feature'lar:
-    - lag_1h..lag_48h: saatlik fiyat gecikmeleri
-    - chg_1h..chg_24h: log değişimleri
-    - ma_6h..ma_48h: hareketli ortalamalar
-    - rsi_14, volatility_24h
-    - volume_ratio, city_price_deviation
-    - target_return_24h: zaman-tabanlı (tolerance ile) 24 saat ileri log getiri × 10000
-    """
     if df.empty:
         return df
 
@@ -298,7 +288,6 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
 
     group_cols = ["item_id", "city"]
 
-    # Saatlik lag'ler
     for lag in [1, 3, 6, 12, 24, 48]:
         df[f"lag_{lag}h"] = df.groupby(group_cols)["avg_price"].shift(lag)
 
@@ -325,17 +314,22 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     city_avg = df.groupby(["item_id", "timestamp"])["avg_price"].transform("mean")
     df["city_price_deviation"] = (df["avg_price"] - city_avg) / city_avg.replace(0, np.nan)
 
-    # ZAMAN-TABANLI HEDEF: her (item_id, city) grubu için 24 saat ilerideki log getiri
-    df = _compute_forward_target(df)
+    # 7 günlük (168h) fiyat aralığındaki yüzdelik konum
+    df["price_pct_7d"] = df.groupby(group_cols)["avg_price"].transform(
+        lambda x: x.rolling(168, min_periods=24).apply(
+            lambda arr: (arr[-1] - np.min(arr)) / (np.max(arr) - np.min(arr) + 1e-9),
+            raw=True
+        )
+    )
 
+    # Fiyat düşüş trendi (12h ve 24h değişimlerin negatif olması)
+    df["is_downtrend"] = ((df["chg_12h"] < 0) & (df["chg_24h"] < 0)).astype(int)
+
+    df = _compute_forward_target(df)
     return df
 
 
 def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Her (item_id, city) grubu için 24 saat ilerideki log fiyatını bulur.
-    shift(-N) yerine merge_asof ile zaman-tabanlı eşleştirme yapar (düzensiz aralıklara dayanıklı).
-    """
     if df.empty or "log_price" not in df.columns:
         df["target_return_24h"] = np.nan
         return df
@@ -394,12 +388,10 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
 
     df = df.dropna(subset=["target_return_24h", "lag_24h"]).copy()
 
-    # Fiyat-benzeri feature'ları log ölçeğine çevir
     for col in PRICE_LIKE_COLS:
         if col in df.columns:
             df[col] = np.log1p(df[col].clip(lower=1.0))
 
-    # Uzun pencereleri doldur
     if "lag_48h" in df.columns:
         df["lag_48h"] = df["lag_48h"].fillna(df["lag_24h"])
     if "ma_48h" in df.columns:
@@ -423,7 +415,6 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
 
     model_df = df.dropna(subset=FEATURE_COLS + ["target_return_24h"]).copy()
 
-    # Hedef clip (bp cinsinden ±1500)
     target_min = MIN_LOG_RETURN * TARGET_SCALE
     target_max = MAX_LOG_RETURN * TARGET_SCALE
     model_df["target_return_24h"] = model_df["target_return_24h"].clip(target_min, target_max)
@@ -442,11 +433,10 @@ def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMRegres
         return None
 
     y_log_std = (y / TARGET_SCALE).std()
-    y_bp_std = y.std()
-    print(f"[TANI] train_global_model: n={len(X)}, y_bp_std={y_bp_std:.4f}, y_log_std={y_log_std:.8f}")
+    print(f"[TANI] train: n={len(X)}, y_log_std={y_log_std:.8f}")
 
     if y_log_std < 1e-6:
-        print(f"⚠️ Hedef log std çok düşük: {y_log_std:.8f}. Model öğrenemez.")
+        print(f"⚠️ Hedef log std çok düşük: {y_log_std:.8f}")
         return None
 
     split_idx = int(len(X) * 0.8)
@@ -485,8 +475,7 @@ def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMRegres
     )
 
     val_preds = model.predict(X_val)
-    pred_std = float(np.std(val_preds))
-    print(f"[TANI] val_pred_std={pred_std:.4f} bp")
+    print(f"[TANI] val_pred_std={float(np.std(val_preds)):.4f} bp")
 
     return model
 
@@ -523,15 +512,14 @@ def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame)
     raw_preds_bp = model.predict(X_ready)
     raw_preds_log = raw_preds_bp / TARGET_SCALE
 
-    pred_std = float(np.std(raw_preds_log))
-    if pred_std < 1e-5:
-        print(f"⚠️ UYARI: Tüm tahminler aynı (std={pred_std:.8f}).")
-
     clipped_log = np.clip(raw_preds_log, MIN_LOG_RETURN, MAX_LOG_RETURN)
     pred_return_pct = (np.exp(clipped_log) - 1) * 100
 
-    result = X_pred.loc[X_ready.index, ["item_id", "city", "avg_price", "item_count",
-                                         "volatility_24h", "rsi_14", "volume_ratio"]].copy()
+    keep_cols = ["item_id", "city", "avg_price", "item_count",
+                 "volatility_24h", "rsi_14", "volume_ratio",
+                 "price_pct_7d", "is_downtrend", "chg_12h", "chg_24h"]
+    keep_cols = [c for c in keep_cols if c in X_pred.columns]
+    result = X_pred.loc[X_ready.index, keep_cols].copy()
     result["raw_log_pred"] = raw_preds_log
     result["clipped_log_pred"] = clipped_log
     result["predicted_log_return_24h"] = clipped_log
@@ -542,21 +530,117 @@ def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame)
     return result
 
 
+# ---------------------------------------------------------------------------
+# DİP ALIM SİNYALİ
+# ---------------------------------------------------------------------------
+
+
+def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
+    """
+    Kural tabanlı dip alım filtresi.
+    Returns: (signal_text, reason_text)
+    
+    Sinyaller:
+    - 🟢 GÜÇLÜ AL: tüm koşullar sağlanıyor
+    - 🟡 ZAYIF AL: çoğu koşul sağlanıyor
+    - 🔵 İZLE: dip bölgesinde ama teyit yok
+    - ⚪ BEKLE: dip değil
+    - 🔴 ALMA: düşüş trendi, model de negatif
+    """
+    reasons = []
+    passed = 0
+    total = 0
+
+    # 1. RSI aşırı satım
+    rsi = row.get("rsi_14", 50)
+    total += 1
+    if pd.notna(rsi) and rsi < DIP_RSI_MAX:
+        passed += 1
+        reasons.append(f"RSI={rsi:.0f}")
+    else:
+        reasons.append(f"RSI={rsi:.0f} (değil)")
+
+    # 2. 7 günlük fiyat percentile
+    pct = row.get("price_pct_7d", 0.5)
+    total += 1
+    if pd.notna(pct) and pct < DIP_PERCENTILE_MAX:
+        passed += 1
+        reasons.append(f"7g%={pct*100:.0f}")
+    else:
+        reasons.append(f"7g%={(pct*100 if pd.notna(pct) else 0):.0f} (yüksek)")
+
+    # 3. Hacim onayı (talep dönüyor)
+    vr = row.get("volume_ratio", 1.0)
+    total += 1
+    if pd.notna(vr) and vr >= DIP_MIN_VOLUME_RATIO:
+        passed += 1
+        reasons.append(f"Hacim×{vr:.1f}")
+    else:
+        reasons.append(f"Hacim×{(vr if pd.notna(vr) else 0):.1f} (zayıf)")
+
+    # 4. Model tahmini çok negatif değil
+    pred_pct = row.get("predicted_return_pct", 0)
+    total += 1
+    if pd.notna(pred_pct) and pred_pct >= DIP_MIN_PREDICTED_PCT:
+        passed += 1
+        reasons.append(f"Model={pred_pct:+.1f}%")
+    else:
+        reasons.append(f"Model={pred_pct:+.1f}% (düşüş)")
+
+    # 5. Likidite yeterli (spread kontrolü)
+    spread = row.get("spread", np.nan)
+    price = row.get("avg_price", 1)
+    total += 1
+    if pd.notna(spread) and price > 0 and abs(spread) / price < DIP_MAX_SPREAD_PCT:
+        passed += 1
+        reasons.append(f"Spread={abs(spread)/price*100:.1f}%")
+    else:
+        reasons.append(f"Spread geniş")
+
+    # 6. Aşırı düşüş trendi DEĞİL (bıçak tutma koruması)
+    is_down = row.get("is_downtrend", 0)
+    chg_24 = row.get("chg_24h", 0)
+    total += 1
+    if not is_down or (pd.notna(pred_pct) and pred_pct > 0.5):
+        passed += 1
+        reasons.append(f"Trend OK")
+    else:
+        reasons.append(f"↓ düşüş trendi")
+
+    # Sinyal kararı
+    if passed >= 5:
+        signal = "🟢 GÜÇLÜ AL"
+    elif passed == 4:
+        signal = "🟡 ZAYIF AL"
+    elif passed == 3 and pd.notna(rsi) and rsi < 45:
+        signal = "🔵 İZLE"
+    elif is_down and pd.notna(pred_pct) and pred_pct < -2:
+        signal = "🔴 ALMA"
+    else:
+        signal = "⚪ BEKLE"
+
+    return signal, " · ".join(reasons)
+
+
 # ---------------------------------------------------------------------------
 # WALK-FORWARD BACKTEST
 # ---------------------------------------------------------------------------
 
 
-def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
+def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 2) -> Dict:
     if featured_df.empty:
         return {"error": "Veri yok."}
 
     df = featured_df.sort_values("timestamp").copy()
     unique_times = df["timestamp"].sort_values().unique()
-    if len(unique_times) < 100:
-        return {"error": "Yeterli zaman noktası yok."}
+
+    if len(unique_times) < 40:
+        return {"error": f"Yeterli zaman noktası yok ({len(unique_times)} < 40)."}
 
     test_size = len(unique_times) // (n_splits + 1)
+    if test_size < 5:
+        return {"error": f"Test boyutu çok küçük ({test_size} < 5)."}
+
     results = []
     all_predictions = []
 
@@ -565,7 +649,7 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
         test_end_idx = test_start_idx + test_size
         if test_end_idx > len(unique_times):
             break
-        train_end_idx = test_start_idx - 48
+        train_end_idx = test_start_idx - 24
         if train_end_idx <= 0:
             continue
 
@@ -575,19 +659,21 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
         train_df = df[df["timestamp"].isin(train_times)]
         test_df = df[df["timestamp"].isin(test_times)]
 
-        if len(train_df) < MIN_TRAIN_SAMPLES or len(test_df) < 20:
+        if len(train_df) < 50 or len(test_df) < 5:
+            print(f"[BACKTEST] split {i+1}: train={len(train_df)}, test={len(test_df)} → atlandı")
             continue
 
         X_train, y_train, _ = prepare_model_data(train_df)
         X_test, y_test, meta_test = prepare_model_data(test_df)
 
-        if len(X_train) < MIN_TRAIN_SAMPLES or len(X_test) < 5:
+        if len(X_train) < 30 or len(X_test) < 3:
+            print(f"[BACKTEST] split {i+1}: X_train={len(X_train)}, X_test={len(X_test)} → atlandı")
             continue
 
         model = lgb.LGBMRegressor(
             objective="regression", metric="mae",
-            num_leaves=31, max_depth=8, min_child_samples=20,
-            learning_rate=0.05, n_estimators=400,
+            num_leaves=15, max_depth=6, min_child_samples=15,
+            learning_rate=0.05, n_estimators=200,
             reg_lambda=0.1, verbose=-1, random_state=42, n_jobs=-1,
         )
         model.fit(X_train, y_train)
@@ -598,7 +684,7 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
         mae = mean_absolute_error(y_test_log, preds)
         rmse = np.sqrt(mean_squared_error(y_test_log, preds))
-        direction_correct = np.mean((y_test_log > 0) == (preds > 0))
+        direction_correct = float(np.mean((y_test_log > 0) == (preds > 0)))
 
         baseline_preds = np.zeros_like(y_test_log)
         baseline_mae = mean_absolute_error(y_test_log, baseline_preds)
@@ -606,8 +692,8 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
         results.append({
             "split": i + 1,
-            "train_samples": len(X_train),
-            "test_samples": len(X_test),
+            "train_samples": int(len(X_train)),
+            "test_samples": int(len(X_test)),
             "mae": round(float(mae), 6),
             "rmse": round(float(rmse), 6),
             "direction_accuracy": round(float(direction_correct), 4),
@@ -620,9 +706,10 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
         test_meta["predicted_return"] = preds
         test_meta["actual_return"] = y_test_log.values
         all_predictions.append(test_meta)
+        print(f"[BACKTEST] split {i+1}: MAE={mae:.6f}, baseline={baseline_mae:.6f}, dir_acc={direction_correct:.3f}")
 
     if not results:
-        return {"error": "Backtest tamamlanamadı."}
+        return {"error": "Backtest tamamlanamadı. Yeterli eğitim/test örneği oluşmadı."}
 
     if all_predictions:
         sim_df = pd.concat(all_predictions)
@@ -738,16 +825,13 @@ class DataPipeline:
         if n_with_target < MIN_TRAIN_SAMPLES:
             self.status_message = (
                 f"Yetersiz hedefli örnek: {n_with_target} < {MIN_TRAIN_SAMPLES}. "
-                f"Toplam: {diag.get('n_total', 0)}, grup: {diag.get('n_groups', 0)}. "
-                f"24 saatlik ileri veri bulunamadı — API çok seyrek olabilir."
+                f"Toplam: {diag.get('n_total', 0)}, grup: {diag.get('n_groups', 0)}."
             )
             return False
 
         if std_log < 1e-6:
             self.status_message = (
-                f"Hedef varyansı çok düşük (std_log={std_log:.8f}, "
-                f"std_bp={diag.get('target_std_bp', 0):.4f}). Model öğrenemez. "
-                f"API'den daha fazla veri çekmeyi deneyin."
+                f"Hedef varyansı çok düşük (std_log={std_log:.8f}). Model öğrenemez."
             )
             return False
 
@@ -764,7 +848,7 @@ class DataPipeline:
         sample_preds = self.model.predict(X.head(500))
         pred_std = float(np.std(sample_preds))
         if pred_std < 1.0:
-            self.status_message = f"⚠️ Model zayıf öğrendi (pred_std={pred_std:.2f} bp). Daha fazla veri gerekli."
+            self.status_message = f"⚠️ Model zayıf öğrendi (pred_std={pred_std:.2f} bp)."
         else:
             self.status_message = f"✓ Model eğitildi ({len(X)} örnek, pred_std={pred_std:.1f} bp)."
 
@@ -810,6 +894,11 @@ class DataPipeline:
         total_cost = SETUP_FEE_RATE + TRANSACTION_TAX_RATE
         preds["net_return_pct"] = preds["predicted_return_pct"] - (total_cost * 100)
 
+        # Dip sinyali hesapla (her satır için)
+        dip_signals = preds.apply(compute_dip_signal, axis=1, result_type="expand")
+        preds["Dip Sinyali"] = dip_signals[0]
+        preds["Sinyal Detayı"] = dip_signals[1]
+
         return preds
 
     def get_backtest(self):
@@ -849,6 +938,7 @@ def get_dashboard_metrics():
         "Ortalama Fiyat": f"{df['avg_price'].mean():.0f} silver",
         "Model Durumu": "Eğitildi" if pipeline.model else "Eğitilmedi",
         "Tahmin Sınırı": f"±%{MAX_LOG_RETURN * 100:.0f}",
+        "Dip Alım Eşiği": f"RSI<{DIP_RSI_MAX:.0f}, 7g%<{DIP_PERCENTILE_MAX*100:.0f}%",
         "Son Güncelleme": pipeline.last_update.strftime("%Y-%m-%d %H:%M") if pipeline.last_update else "—",
     }
     return pd.DataFrame(list(metrics.items()), columns=["Metrik", "Değer"])
@@ -874,10 +964,13 @@ def get_analysis_table():
     latest["Mevcut Fiyat"] = latest["avg_price"].round(0)
     latest["Hacim"] = latest["item_count"].fillna(0).astype(int)
     latest["Spread"] = (latest["sell_price_min"] - latest["buy_price_max"]).round(0)
+    latest["RSI"] = latest["rsi_14"].round(0)
+    latest["7g Konum %"] = (latest["price_pct_7d"] * 100).round(0)
+    latest["Trend"] = np.where(latest["is_downtrend"] == 1, "↓ Düşüş", "→ Yatay/Yukarı")
     latest["Likidite"] = pd.cut(latest["item_count"], bins=[-1, 10, 50, 200, np.inf],
                                  labels=["Düşük", "Orta", "İyi", "Yüksek"]).astype(str)
 
-    return latest[["Ürün", "Şehir", "Mevcut Fiyat", "Hacim", "Spread", "Likidite"]].sort_values("Hacim", ascending=False).head(100)
+    return latest[["Ürün", "Şehir", "Mevcut Fiyat", "Hacim", "Spread", "RSI", "7g Konum %", "Trend", "Likidite"]].sort_values("Hacim", ascending=False).head(100)
 
 
 def get_prediction_table():
@@ -892,18 +985,56 @@ def get_prediction_table():
     preds["Tahmini Fiyat (24s)"] = preds["predicted_price_24h"].round(0)
     preds["Tahmini Değişim %"] = preds["predicted_return_pct"].round(2)
     preds["Güvenilirlik"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["Spread"] = preds["spread"].round(0)
     preds["Net Getiri % (maliyet sonrası)"] = preds["net_return_pct"].round(2)
     preds["Likidite"] = pd.cut(preds["item_count"], bins=[-1, 10, 50, 200, np.inf],
                                 labels=["Düşük", "Orta", "İyi", "Yüksek"]).astype(str)
-    preds["Not"] = np.where(preds["is_uncertain"], "⚠️ Belirsiz", "")
 
     cols = ["Ürün", "Şehir", "Mevcut Fiyat", "Tahmini Fiyat (24s)",
-            "Tahmini Değişim %", "Güvenilirlik", "Spread", "Likidite",
-            "Net Getiri % (maliyet sonrası)", "Not"]
+            "Tahmini Değişim %", "Güvenilirlik", "Likidite",
+            "Net Getiri % (maliyet sonrası)", "Dip Sinyali"]
     return preds[cols].sort_values("Tahmini Değişim %", ascending=False)
 
 
+def get_dip_alim_table():
+    """Sadece DİP ALIM sinyali veren ürünler, sinyal gücüne göre sıralı."""
+    preds = pipeline.get_latest_predictions()
+    if preds.empty:
+        return pd.DataFrame({"Bilgi": ["Tahmin üretilemedi."]})
+
+    # Sadece AL/İZLE sinyalleri
+    dip_only = preds[preds["Dip Sinyali"].isin(
+        ["🟢 GÜÇLÜ AL", "🟡 ZAYIF AL", "🔵 İZLE"]
+    )].copy()
+
+    if dip_only.empty:
+        return pd.DataFrame({"Bilgi": [
+            "Şu anda dip alım sinyali yok. Daha fazla veri veya farklı eşikler gerekebilir."
+        ]})
+
+    # Sıralama: sinyal gücü > güvenilirlik > tahmini değişim
+    signal_order = {"🟢 GÜÇLÜ AL": 0, "🟡 ZAYIF AL": 1, "🔵 İZLE": 2}
+    dip_only["_sig_rank"] = dip_only["Dip Sinyali"].map(signal_order)
+
+    dip_only["Ürün"] = dip_only["item_id"].apply(item_display_name)
+    dip_only["Şehir"] = dip_only["city"]
+    dip_only["Mevcut Fiyat"] = dip_only["avg_price"].round(0)
+    dip_only["RSI"] = dip_only["rsi_14"].round(0)
+    dip_only["7g Konum %"] = (dip_only["price_pct_7d"] * 100).round(0)
+    dip_only["Trend"] = np.where(dip_only["is_downtrend"] == 1, "↓", "→")
+    dip_only["Hacim×Ort"] = dip_only["volume_ratio"].round(1)
+    dip_only["Tahmini Değişim %"] = dip_only["predicted_return_pct"].round(2)
+    dip_only["Net Getiri %"] = dip_only["net_return_pct"].round(2)
+    dip_only["Güvenilirlik"] = (dip_only["confidence"] * 100).round(0).astype(int).astype(str) + "%"
+    dip_only["Spread"] = dip_only["spread"].round(0)
+
+    dip_only = dip_only.sort_values(["_sig_rank", "confidence"], ascending=[True, False])
+
+    cols = ["Dip Sinyali", "Ürün", "Şehir", "Mevcut Fiyat", "RSI", "7g Konum %",
+            "Trend", "Hacim×Ort", "Tahmini Değişim %", "Net Getiri %",
+            "Güvenilirlik", "Spread", "Sinyal Detayı"]
+    return dip_only[cols].head(50)
+
+
 def get_arbitrage_table():
     if pipeline.prices_df.empty:
         return pd.DataFrame({"Bilgi": ["Anlık fiyat yok."]})
@@ -1023,6 +1154,7 @@ def refresh_data_ui():
         _safe(get_dashboard_metrics, pd.DataFrame()),
         _safe(get_analysis_table, pd.DataFrame()),
         _safe(get_prediction_table, pd.DataFrame()),
+        _safe(get_dip_alim_table, pd.DataFrame()),
         _safe(get_arbitrage_table, pd.DataFrame()),
         _safe(get_model_performance_plot, go.Figure().update_layout(title="—", template="plotly_dark")),
         bt_table, bt_fig, sim_table,
@@ -1039,7 +1171,7 @@ def initial_load():
 
     return (
         _safe(get_dashboard_metrics, pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})),
-        pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
+        pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
         go.Figure().update_layout(title="Yenile butonuna basın", template="plotly_dark"),
         pd.DataFrame(),
         go.Figure().update_layout(title="Veri gerekli", template="plotly_dark"),
@@ -1059,11 +1191,10 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         """
         # 🦅 GOSHAWK ALBION MARKET AI
         **Profesyonel Market Intelligence Dashboard** | Avrupa Sunucusu
-        *LightGBM tabanlı 24 saatlik fiyat tahmini ve arbitraj analizi.*
-
-        **Tahmin sınırı:** ±%15 · **Hedef ölçeği:** baz puan · **Veri:** saatlik · **Hedef:** zaman-tabanlı (24h, tolerans ±12h)
+        *LightGBM tabanlı 24 saatlik fiyat tahmini + kural-tabanlı dip alım sinyali.*
 
-        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir ve kesin kazanç garantisi sunmaz.
+        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir.
+        "Dip alım" sinyali **sadece** istatistiksel bir filtredir; fiyat daha da düşebilir.
         """
     )
 
@@ -1075,27 +1206,42 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         with gr.TabItem("📊 Dashboard"):
             dashboard_table = gr.Dataframe(label="Özet & Teşhis", interactive=False, wrap=True)
             gr.Markdown(
-                "### Kalibrasyon\n"
-                "- Saatlik veri (`time-scale=1`) → 24h hedef için ~24 nokta\n"
-                "- Hedef **zaman-tabanlı** (merge_asof, tolerans ±12h) — düzensiz aralıklara dayanıklı\n"
-                "- Hedef baz puan (×10000) → model daha stabil öğrenir\n"
-                "- Fiyat feature'ları `log1p` ile normalize\n"
-                "- Tahmin ±%15 aralığına clip\n"
-                "- |tahmin| < 1% ise **belirsiz** işaretlenir\n\n"
-                "### Teşhis sütunları\n"
-                "- **Hedefli Satır:** `target_return_24h` NaN olmayan satır sayısı\n"
-                "- **Hedef std (log):** 0.005-0.05 arası ise model öğrenebilir\n"
-                "- **Model Durumu:** Eğitildi = hazır\n\n"
+                "### Dip Alım Sinyali Mantığı\n"
+                "**Fiyat düşerken almak** = riskli. Model bunu doğru şekilde **filtreler**:\n\n"
+                "**6 koşuldan en az 4'ü sağlanırsa** AL sinyali:\n"
+                "1. RSI < 40 (aşırı satım)\n"
+                "2. 7 günlük aralıkta alt %25'te\n"
+                "3. Hacim ortalamanın üstünde (talep dönüyor)\n"
+                "4. Model tahmini çok negatif değil (> -1%)\n"
+                "5. Spread dar (likit)\n"
+                "6. Aşırı düşüş trendi DEĞİL (bıçak tutma koruması)\n\n"
+                "### Sinyaller\n"
+                "- 🟢 **GÜÇLÜ AL:** 5+ koşul\n"
+                "- 🟡 **ZAYIF AL:** 4 koşul\n"
+                "- 🔵 **İZLE:** 3 koşul + RSI<45\n"
+                "- 🔴 **ALMA:** düşüş trendi + model negatif\n"
+                "- ⚪ **BEKLE:** diğer\n\n"
                 "### Riskler\n"
-                "- Tahminler olasılıksaldır; kesin kazanç garantisi yoktur"
+                "- Model tahminleri olasılıksaldır\n"
+                "- Dip alım her zaman işe yaramaz, stop-loss kullanın"
             )
 
-        with gr.TabItem("📦 100 Ürün Analizi"):
-            analysis_table = gr.Dataframe(label="Ürün Analizi", interactive=False)
+        with gr.TabItem("🎯 DİP ALIM FIRSATLARI"):
+            dip_alim_table = gr.Dataframe(label="Dip Alım Sinyalleri (Fiyat düşerken al)", interactive=False)
+            gr.Markdown(
+                "*Bu tablo **sadece** dip alım sinyali veren ürünleri gösterir. "
+                "🟢 GÜÇLÜ AL en yüksek öncelikli. "
+                "**Sinyal Detayı** sütunu hangi koşulların sağlandığını gösterir.*\n\n"
+                "**⚠️ UYARI:** Fiyat düşerken almak, trend dönerse kârlıdır. "
+                "Ama trend devam ederse zarar eder. "
+                "Sadece **likit** ürünlerde ve **küçük pozisyonlarla** deneyin."
+            )
 
-        with gr.TabItem("🔮 24 Saatlik Fiyat Tahmini"):
-            prediction_table = gr.Dataframe(label="Tahminler", interactive=False)
-            gr.Markdown("*⚠️ Belirsiz = model sinyali zayıf. Net getiri %2.5+%8 maliyet düşülmüş halidir.*")
+        with gr.TabItem("🔮 24s Tahmin"):
+            prediction_table = gr.Dataframe(label="Tüm Tahminler + Dip Sinyali", interactive=False)
+
+        with gr.TabItem("📦 100 Ürün Analizi"):
+            analysis_table = gr.Dataframe(label="Ürün Analizi (RSI, Trend, Konum)", interactive=False)
 
         with gr.TabItem("🚚 Arbitraj"):
             arbitrage_table = gr.Dataframe(label="Arbitraj Fırsatları", interactive=False)
@@ -1106,13 +1252,16 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         with gr.TabItem("🧪 Backtest"):
             backtest_table = gr.Dataframe(label="Split Sonuçları", interactive=False)
             backtest_plot = gr.Plot(label="MAE Karşılaştırması")
-            simulation_table = gr.Dataframe(label="Simülasyon", interactive=False)
+            simulation_table = gr.Dataframe(label="Simülasyon (maliyetler sonrası)", interactive=False)
 
         with gr.TabItem("🗄️ Veri Yönetimi"):
             gr.Markdown(
                 "**API:** `europe.albion-online-data.com/api/v2`\n"
                 "**Time-scale:** 1h (saatlik)\n"
-                "**Model:** `gos_hawk_data/models/gos_hawk_model.pkl`"
+                "**Model:** `gos_hawk_data/models/gos_hawk_model.pkl`\n\n"
+                "**Dip Alım Parametreleri:** "
+                f"RSI<{DIP_RSI_MAX}, 7g%<{DIP_PERCENTILE_MAX*100:.0f}%, "
+                f"Hacim≥{DIP_MIN_VOLUME_RATIO}, Spread<%{DIP_MAX_SPREAD_PCT*100:.0f}"
             )
             csv_files = gr.Dataframe(label="CSV Dosyaları", interactive=False,
                                      headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])
@@ -1121,15 +1270,16 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         fn=refresh_data_ui,
         inputs=[],
         outputs=[status_text, dashboard_table, analysis_table, prediction_table,
-                 arbitrage_table, performance_plot, backtest_table, backtest_plot,
-                 simulation_table, csv_files],
+                 dip_alim_table, arbitrage_table, performance_plot, backtest_table,
+                 backtest_plot, simulation_table, csv_files],
     )
 
     demo.load(
         fn=initial_load,
         inputs=[],
-        outputs=[dashboard_table, analysis_table, prediction_table, arbitrage_table,
-                 performance_plot, backtest_table, backtest_plot, simulation_table, csv_files],
+        outputs=[dashboard_table, analysis_table, prediction_table, dip_alim_table,
+                 arbitrage_table, performance_plot, backtest_table, backtest_plot,
+                 simulation_table, csv_files],
     )