Update app.py

app.py

@@ -95,13 +95,14 @@ os.makedirs(MODEL_DIR, exist_ok=True)
 MODEL_PATH = os.path.join(MODEL_DIR, "gos_hawk_model.pkl")
 
 MIN_TRAIN_SAMPLES = 150
-REQUEST_TIMEOUT = 30
+REQUEST_TIMEOUT = 60        # daha uzun timeout (saatlik veri için)
 MAX_RETRIES = 3
 RETRY_BACKOFF = 2
-HISTORY_TIME_SCALE = 6
 
-# KRİTİK: Hedef ölçeği — log getiri * 10000 = baz puan
-# Bu, modelin 0.1-1 aralığında öğrenmesini sağlar → stabil
+# 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)
@@ -111,6 +112,26 @@ 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ı
+FEATURE_COLS = [
+    "hour", "dayofweek", "is_weekend",
+    "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
+    "chg_1h", "chg_6h", "chg_12h", "chg_24h",
+    "ma_6h", "ma_12h", "ma_24h", "ma_48h",
+    "rsi_14", "volatility_24h",
+    "volume_ma_24h", "volume_ratio",
+    "city_price_deviation",
+    "item_code", "city_code",
+]
+
+PRICE_LIKE_COLS = [
+    "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
+    "ma_6h", "ma_12h", "ma_24h", "ma_48h",
+]
+
 # ---------------------------------------------------------------------------
 # PUBLIC API ÇAĞRILARI
 # ---------------------------------------------------------------------------
@@ -118,7 +139,7 @@ LOW_CONFIDENCE_THRESHOLD = 0.01
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
     headers = {
-        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.3 (public-api-client)",
+        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.4 (public-api-client)",
         "Accept": "application/json",
     }
     for attempt in range(MAX_RETRIES):
@@ -168,9 +189,9 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
     return df
 
 
-def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6, qualities: str = "1") -> pd.DataFrame:
+def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 1, qualities: str = "1") -> pd.DataFrame:
     all_records = []
-    chunk_size = 30
+    chunk_size = 20  # saatlik veri daha ağır → daha küçük chunk
     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"
@@ -188,7 +209,7 @@ def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6, q
                         "avg_price": point.get("avg_price"),
                         "item_count": point.get("item_count", 0),
                     })
-        time.sleep(0.4)
+        time.sleep(0.5)
     if not all_records:
         return pd.DataFrame()
 
@@ -215,6 +236,7 @@ def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
     df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce").astype("float64")
     df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
     df = df[df["avg_price"] > 0].copy()
+    df = df.dropna(subset=["timestamp"]).copy()
 
     for item in df["item_id"].unique():
         mask = df["item_id"] == item
@@ -254,6 +276,15 @@ 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
 
@@ -267,10 +298,12 @@ 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)
 
     df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
+
     for chg in [1, 6, 12, 24]:
         df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
 
@@ -281,11 +314,9 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
         )
 
     df["rsi_14"] = df.groupby(group_cols)["avg_price"].transform(lambda x: compute_rsi(x, 14))
-
     df["volatility_24h"] = df.groupby(group_cols)["log_price"].transform(
         lambda x: x.rolling(24, min_periods=6).std()
     )
-
     df["volume_ma_24h"] = df.groupby(group_cols)["item_count"].transform(
         lambda x: x.rolling(24, min_periods=6).mean()
     )
@@ -294,8 +325,56 @@ 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)
 
-    # KRİTİK: hedef ölçeği = log getiri * 10000 (baz puan)
-    df["target_return_24h"] = df.groupby(group_cols)["log_price"].shift(-4) * TARGET_SCALE
+    # ZAMAN-TABANLI HEDEF: her (item_id, city) grubu için 24 saat ilerideki log getiri
+    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
+
+    df["target_return_24h"] = np.nan
+
+    for (item_id, city), g in df.groupby(["item_id", "city"]):
+        if len(g) < 5:
+            continue
+
+        g = g.sort_values("timestamp")
+        left = pd.DataFrame({
+            "timestamp": g["timestamp"].values,
+            "log_price_now": g["log_price"].values,
+            "idx": g.index.values,
+        })
+        right = pd.DataFrame({
+            "timestamp": g["timestamp"].values,
+            "log_price_future": g["log_price"].values,
+        }).sort_values("timestamp")
+
+        left["target_timestamp"] = left["timestamp"] + pd.Timedelta(hours=24)
+
+        merged = pd.merge_asof(
+            left.sort_values("target_timestamp"),
+            right.sort_values("timestamp"),
+            left_on="target_timestamp",
+            right_on="timestamp",
+            direction="nearest",
+            tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS),
+            suffixes=("", "_future"),
+        )
+
+        future_log = merged["log_price_future"].values
+        current_log = merged["log_price_now"].values
+        target_log = future_log - current_log
+        idx = merged["idx"].values
+
+        df.loc[idx, "target_return_24h"] = target_log * TARGET_SCALE
 
     return df
 
@@ -304,23 +383,8 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
 # MODEL EĞİTİMİ
 # ---------------------------------------------------------------------------
 
-FEATURE_COLS = [
-    "hour", "dayofweek", "is_weekend",
-    "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
-    "chg_1h", "chg_6h", "chg_12h", "chg_24h",
-    "ma_6h", "ma_12h", "ma_24h", "ma_48h",
-    "rsi_14", "volatility_24h",
-    "volume_ma_24h", "volume_ratio",
-    "city_price_deviation",
-    "item_code", "city_code",
-]
-
 
 def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series, pd.DataFrame]:
-    """
-    Feature engineering çıktısını modele hazırlar.
-    KRİTİK: Fiyat-benzeri feature'lar log1p ile normalize edilir.
-    """
     if featured_df.empty:
         return pd.DataFrame(), pd.Series(dtype=float), pd.DataFrame()
 
@@ -328,14 +392,10 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
     df["item_code"] = df["item_id"].astype("category").cat.codes
     df["city_code"] = df["city"].astype("category").cat.codes
 
-    df = df.dropna(subset=["target_return_24h", "lag_1h", "lag_24h"]).copy()
+    df = df.dropna(subset=["target_return_24h", "lag_24h"]).copy()
 
-    # KRİTİK: Fiyat-benzeri feature'ları log ölçeğine çevir (binlerce silver → ~7-10)
-    price_like_cols = [
-        "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
-        "ma_6h", "ma_12h", "ma_24h", "ma_48h",
-    ]
-    for col in price_like_cols:
+    # 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))
 
@@ -347,6 +407,10 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
     if "ma_24h" in df.columns:
         df["ma_24h"] = df["ma_24h"].fillna(df["lag_24h"])
 
+    for lag_col in ["lag_1h", "lag_3h", "lag_6h", "lag_12h"]:
+        if lag_col in df.columns:
+            df[lag_col] = df[lag_col].fillna(df["lag_24h"])
+
     for chg in ["chg_1h", "chg_6h", "chg_12h", "chg_24h"]:
         if chg in df.columns:
             df[chg] = df[chg].fillna(0.0)
@@ -359,7 +423,7 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
 
     model_df = df.dropna(subset=FEATURE_COLS + ["target_return_24h"]).copy()
 
-    # KRİTİK: Target zaten baz puan (×10000). Şimdi ±1500 bp (≈ ±0.15 log) sınırı
+    # 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)
@@ -377,17 +441,18 @@ def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMRegres
         print(f"Yetersiz veri: {len(X)} < {MIN_TRAIN_SAMPLES}")
         return None
 
-    # Hedef baz puan ölçeğinde → standart sapma ~100-300 bp
-    y_std = y.std()
-    if y_std < 1e-3:
-        print(f"⚠️ Hedef standart sapması çok düşük: {y_std}. Model öğrenemez.")
+    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}")
+
+    if y_log_std < 1e-6:
+        print(f"⚠️ Hedef log std çok düşük: {y_log_std:.8f}. Model öğrenemez.")
         return None
 
     split_idx = int(len(X) * 0.8)
     X_train, X_val = X.iloc[:split_idx], X.iloc[split_idx:]
     y_train, y_val = y.iloc[:split_idx], y.iloc[split_idx:]
 
-    # Regularizasyon DENGELİ — overfit değil, underfit de değil
     model = lgb.LGBMRegressor(
         objective="regression",
         metric="mae",
@@ -419,18 +484,14 @@ def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMRegres
         callbacks=callbacks,
     )
 
-    # Öğrendi mi kontrolü
     val_preds = model.predict(X_val)
-    if np.std(val_preds) < 1e-3:
-        print(f"⚠️ Validation tahminleri neredeyse sabit (std={np.std(val_preds):.6f}). Model öğrenmedi.")
+    pred_std = float(np.std(val_preds))
+    print(f"[TANI] val_pred_std={pred_std:.4f} bp")
 
     return model
 
 
 def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame) -> pd.DataFrame:
-    """
-    Ham tahmin baz puan cinsinden → log getiriye çevir → clip → exp.
-    """
     if latest_features.empty or model is None:
         return pd.DataFrame()
 
@@ -439,13 +500,9 @@ def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame)
         print(f"Eksik özellikler: {missing}")
         return pd.DataFrame()
 
-    # KRİTİK: predict öncesi de aynı log1p dönüşümü uygula
     X_pred = latest_features.copy()
-    price_like_cols = [
-        "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
-        "ma_6h", "ma_12h", "ma_24h", "ma_48h",
-    ]
-    for col in price_like_cols:
+
+    for col in PRICE_LIKE_COLS:
         if col in X_pred.columns:
             X_pred[col] = np.log1p(X_pred[col].clip(lower=1.0))
 
@@ -463,17 +520,14 @@ def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame)
     if X_ready.empty:
         return pd.DataFrame()
 
-    raw_preds_bp = model.predict(X_ready)  # baz puan
-    raw_preds_log = raw_preds_bp / TARGET_SCALE  # log getiri
+    raw_preds_bp = model.predict(X_ready)
+    raw_preds_log = raw_preds_bp / TARGET_SCALE
 
-    # Tahmin çeşitliliği kontrolü
-    pred_std = np.std(raw_preds_log)
+    pred_std = float(np.std(raw_preds_log))
     if pred_std < 1e-5:
         print(f"⚠️ UYARI: Tüm tahminler aynı (std={pred_std:.8f}).")
 
-    # Aşırı değerleri clip'le
     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",
@@ -499,7 +553,7 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
     df = featured_df.sort_values("timestamp").copy()
     unique_times = df["timestamp"].sort_values().unique()
-    if len(unique_times) < 50:
+    if len(unique_times) < 100:
         return {"error": "Yeterli zaman noktası yok."}
 
     test_size = len(unique_times) // (n_splits + 1)
@@ -507,11 +561,11 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
     all_predictions = []
 
     for i in range(n_splits):
-        test_start_idx = test_size * (i + 1) + 4
+        test_start_idx = test_size * (i + 1) + 24
         test_end_idx = test_start_idx + test_size
         if test_end_idx > len(unique_times):
             break
-        train_end_idx = test_start_idx - 8
+        train_end_idx = test_start_idx - 48
         if train_end_idx <= 0:
             continue
 
@@ -606,6 +660,7 @@ class DataPipeline:
         self.last_update = None
         self.status_message = "Veri yüklenmedi. 'Verileri Yenile' butonuna basın."
         self._backtest_cache = None
+        self._diagnostics = {}
 
         if _HAS_JOBLIB and os.path.exists(MODEL_PATH):
             try:
@@ -644,21 +699,61 @@ class DataPipeline:
 
         self.featured_df = build_features(self.history_df)
         self._backtest_cache = None
+        self._update_diagnostics()
+
+    def _update_diagnostics(self):
+        df = self.featured_df
+        if df.empty:
+            self._diagnostics = {}
+            return
+        n_total = len(df)
+        n_with_target = int(df["target_return_24h"].notna().sum())
+        n_groups = int(df.groupby(["item_id", "city"]).ngroups)
+        if n_with_target > 0:
+            target_bp = df["target_return_24h"].dropna()
+            target_std_bp = float(target_bp.std())
+            target_std_log = target_std_bp / TARGET_SCALE
+        else:
+            target_std_bp = 0.0
+            target_std_log = 0.0
+        self._diagnostics = {
+            "n_total": n_total,
+            "n_with_target": n_with_target,
+            "n_groups": n_groups,
+            "target_std_bp": target_std_bp,
+            "target_std_log": target_std_log,
+        }
+        print(f"[TANI] total={n_total}, hedefli={n_with_target}, grup={n_groups}, "
+              f"std_bp={target_std_bp:.4f}, std_log={target_std_log:.8f}")
 
     def train_model(self):
         if self.featured_df.empty:
             self.status_message = "Önce veri çekmelisiniz."
             return False
 
-        X, y, _ = prepare_model_data(self.featured_df)
-        if len(X) < MIN_TRAIN_SAMPLES:
-            self.status_message = f"Yetersiz örnek: {len(X)} (min {MIN_TRAIN_SAMPLES})"
+        diag = self._diagnostics or {}
+        n_with_target = diag.get("n_with_target", 0)
+        std_log = diag.get("target_std_log", 0.0)
+
+        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."
+            )
             return False
 
-        # Hedef dağılımı kontrolü
-        y_std = y.std()
-        if y_std < 1e-3:
-            self.status_message = f"Hedef varyansı çok düşük (std={y_std:.4f}). Model öğrenemez."
+        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."
+            )
+            return False
+
+        X, y, _ = prepare_model_data(self.featured_df)
+        if len(X) < MIN_TRAIN_SAMPLES:
+            self.status_message = f"Model eğitimi için yetersiz örnek: {len(X)} < {MIN_TRAIN_SAMPLES}"
             return False
 
         self.model = train_global_model(X, y)
@@ -666,13 +761,12 @@ class DataPipeline:
             self.status_message = "Model eğitimi başarısız."
             return False
 
-        # Tahmin çeşitliliği kontrolü (eğitim setinde)
         sample_preds = self.model.predict(X.head(500))
-        pred_std = np.std(sample_preds)
-        if pred_std < 1.0:  # bp cinsinden
-            self.status_message = f"⚠️ Model öğrenmedi (std={pred_std:.4f} bp). Daha fazla veri gerekli."
+        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."
         else:
-            self.status_message = f"Model eğitildi ({len(X)} örnek, pred_std={pred_std:.1f} bp)."
+            self.status_message = f"✓ Model eğitildi ({len(X)} örnek, pred_std={pred_std:.1f} bp)."
 
         if _HAS_JOBLIB:
             try:
@@ -733,6 +827,7 @@ pipeline = DataPipeline()
 
 
 def get_dashboard_metrics():
+    diag = pipeline._diagnostics
     if pipeline.featured_df.empty:
         return pd.DataFrame({
             "Metrik": ["Durum", "Veri Kaynağı", "Model"],
@@ -742,15 +837,18 @@ def get_dashboard_metrics():
     df = pipeline.featured_df
     metrics = {
         "Veri Kaynağı": "Public AODP API (europe)",
-        "Time-scale": f"{HISTORY_TIME_SCALE}h",
+        "Time-scale": f"{HISTORY_TIME_SCALE}h (saatlik)",
         "Toplam Gözlem": len(df),
         "Ürün Sayısı": df["item_id"].nunique(),
         "Şehir Sayısı": df["city"].nunique(),
+        "Grup Sayısı": diag.get("n_groups", 0),
+        "Hedefli Satır": diag.get("n_with_target", 0),
+        "Hedef std (log)": f"{diag.get('target_std_log', 0):.6f}",
+        "Hedef std (bp)": f"{diag.get('target_std_bp', 0):.2f}",
         "Tarih Aralığı": f"{df['timestamp'].min().date()} - {df['timestamp'].max().date()}",
         "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}",
-        "Hedef Ölçeği": f"baz puan (×{TARGET_SCALE:.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"])
@@ -866,7 +964,9 @@ def get_model_performance_plot():
 def get_backtest_outputs():
     bt = pipeline.get_backtest()
     if "error" in bt:
-        return pd.DataFrame({"Bilgi": [bt["error"]]}), go.Figure().update_layout(title="Backtest hatası", template="plotly_dark"), pd.DataFrame()
+        return (pd.DataFrame({"Bilgi": [bt["error"]]}),
+                go.Figure().update_layout(title="Backtest hatası", template="plotly_dark"),
+                pd.DataFrame())
 
     results_df = pd.DataFrame(bt["results"])
     fig = go.Figure()
@@ -961,7 +1061,7 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         **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 (×10000)
+        **Tahmin sınırı:** ±%15 · **Hedef ölçeği:** baz puan · **Veri:** saatlik · **Hedef:** zaman-tabanlı (24h, tolerans ±12h)
 
         **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir ve kesin kazanç garantisi sunmaz.
         """
@@ -973,17 +1073,21 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
 
     with gr.Tabs():
         with gr.TabItem("📊 Dashboard"):
-            dashboard_table = gr.Dataframe(label="Özet", interactive=False, wrap=True)
+            dashboard_table = gr.Dataframe(label="Özet & Teşhis", interactive=False, wrap=True)
             gr.Markdown(
                 "### Kalibrasyon\n"
-                "- Hedef baz puan ölçeğinde (×10000) → model daha stabil öğrenir\n"
-                "- Fiyat feature'ları `log1p` ile normalize edilir\n"
-                "- Tahmin ±%15 aralığına clip'lenir\n"
-                "- |tahmin| < 1% ise **belirsiz** olarak işaretlenir\n\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"
                 "### Riskler\n"
-                "- Model tahminleri **olasılıksaldır**\n"
-                "- Geçmiş performans gelecek garantisi değildir\n"
-                "- Spread ve likidite düşükse gerçekleşme fiyatı sapabilir"
+                "- Tahminler olasılıksaldır; kesin kazanç garantisi yoktur"
             )
 
         with gr.TabItem("📦 100 Ürün Analizi"):
@@ -1005,7 +1109,11 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
             simulation_table = gr.Dataframe(label="Simülasyon", interactive=False)
 
         with gr.TabItem("🗄️ Veri Yönetimi"):
-            gr.Markdown("**API:** `europe.albion-online-data.com/api/v2`\n**Model:** `gos_hawk_data/models/gos_hawk_model.pkl`")
+            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`"
+            )
             csv_files = gr.Dataframe(label="CSV Dosyaları", interactive=False,
                                      headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])