Update app.py

app.py

@@ -35,12 +35,8 @@ warnings.filterwarnings("ignore")
 API_BASE = "https://europe.albion-online-data.com/api/v2"
 
 CITIES = [
-    "Bridgewatch",
-    "Fort Sterling",
-    "Lymhurst",
-    "Martlock",
-    "Thetford",
-    "Caerleon",
+    "Bridgewatch", "Fort Sterling", "Lymhurst",
+    "Martlock", "Thetford", "Caerleon",
 ]
 
 _ITEM_POOL = [
@@ -94,35 +90,26 @@ TRANSACTION_TAX_RATE = 0.08
 
 DATA_DIR = "gos_hawk_data"
 os.makedirs(DATA_DIR, exist_ok=True)
-
 MODEL_DIR = os.path.join(DATA_DIR, "models")
 os.makedirs(MODEL_DIR, exist_ok=True)
 MODEL_PATH = os.path.join(MODEL_DIR, "gos_hawk_model.pkl")
 
-PURGE_HOURS = 24
-EMBARGO_HOURS = 24
 MIN_TRAIN_SAMPLES = 150
-
 REQUEST_TIMEOUT = 30
 MAX_RETRIES = 3
 RETRY_BACKOFF = 2
-
 HISTORY_TIME_SCALE = 6
 
-# ---------------------------------------------------------------------------
-# TAHMİN SINIRLARI (aşırı tahminleri engelle)
-# ---------------------------------------------------------------------------
+# KRİTİK: Hedef ölçeği — log getiri * 10000 = baz puan
+# Bu, modelin 0.1-1 aralığında öğrenmesini sağlar → stabil
+TARGET_SCALE = 10000.0
 
-# 24h'lik gerçekçi max log getiri aralığı (yaklaşık ±%15)
+# Tahmin clip (log getiri, ±%15)
 MAX_LOG_RETURN = 0.15
 MIN_LOG_RETURN = -0.15
 
-# Eğitim target clip (log uzayında)
-TARGET_CLIP_LOWER_Q = 0.02
-TARGET_CLIP_UPPER_Q = 0.98
-
-# Güven eşiği: bu log getirinin altındaki tahminler "belirsiz" sayılır
-LOW_CONFIDENCE_THRESHOLD = 0.02
+# Belirsizlik eşiği (log getiri)
+LOW_CONFIDENCE_THRESHOLD = 0.01
 
 # ---------------------------------------------------------------------------
 # PUBLIC API ÇAĞRILARI
@@ -131,7 +118,7 @@ LOW_CONFIDENCE_THRESHOLD = 0.02
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
     headers = {
-        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.2 (public-api-client)",
+        "User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.3 (public-api-client)",
         "Accept": "application/json",
     }
     for attempt in range(MAX_RETRIES):
@@ -145,7 +132,6 @@ def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
                 time.sleep(wait)
                 continue
             elif resp.status_code >= 500:
-                print(f"Sunucu hatası {resp.status_code}. Yeniden deneniyor...")
                 time.sleep(RETRY_BACKOFF * (attempt + 1))
                 continue
             else:
@@ -166,10 +152,8 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
     chunk_size = 50
     for i in range(0, len(item_ids), chunk_size):
         chunk = item_ids[i:i+chunk_size]
-        items_str = ",".join(chunk)
-        locations_str = ",".join(cities)
-        url = f"{API_BASE}/stats/prices/{items_str}.json"
-        params = {"locations": locations_str, "qualities": qualities}
+        url = f"{API_BASE}/stats/prices/{','.join(chunk)}.json"
+        params = {"locations": ",".join(cities), "qualities": qualities}
         data = safe_request(url, params)
         if data:
             all_data.extend(data)
@@ -181,9 +165,6 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
     for col in ["sell_price_min", "sell_price_max", "buy_price_min", "buy_price_max"]:
         if col in df.columns:
             df[col] = pd.to_numeric(df[col], errors="coerce").astype("float64")
-    for col in ["sell_price_min_date", "sell_price_max_date", "buy_price_min_date", "buy_price_max_date"]:
-        if col in df.columns:
-            df[col] = pd.to_datetime(df[col], errors="coerce")
     return df
 
 
@@ -192,21 +173,17 @@ def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6, q
     chunk_size = 30
     for i in range(0, len(item_ids), chunk_size):
         chunk = item_ids[i:i+chunk_size]
-        items_str = ",".join(chunk)
-        locations_str = ",".join(cities)
-        url = f"{API_BASE}/stats/history/{items_str}.json"
-        params = {"locations": locations_str, "qualities": qualities, "time-scale": time_scale}
+        url = f"{API_BASE}/stats/history/{','.join(chunk)}.json"
+        params = {"locations": ",".join(cities), "qualities": qualities, "time-scale": time_scale}
         data = safe_request(url, params)
         if data:
             for entry in data:
                 item_id = entry.get("item_id")
                 loc = entry.get("location")
-                quality = entry.get("quality", 1)
                 for point in entry.get("data", []):
                     all_records.append({
                         "item_id": item_id,
                         "city": loc,
-                        "quality": quality,
                         "timestamp": point.get("timestamp"),
                         "avg_price": point.get("avg_price"),
                         "item_count": point.get("item_count", 0),
@@ -225,13 +202,10 @@ def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6, q
 def check_api_health() -> Tuple[bool, str]:
     try:
         url = f"{API_BASE}/stats/prices/T4_BAG.json"
-        params = {"locations": "Bridgewatch", "qualities": "1"}
-        data = safe_request(url, params)
-        if data is not None:
-            return True, "Public API erişilebilir."
-        return False, "Public API yanıt vermedi."
+        data = safe_request(url, {"locations": "Bridgewatch", "qualities": "1"})
+        return (True, "OK") if data is not None else (False, "Yanıt yok")
     except Exception as e:
-        return False, f"API kontrol hatası: {e}"
+        return False, str(e)
 
 
 def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
@@ -239,22 +213,19 @@ def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
         return df
     df = df.copy()
     df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce").astype("float64")
-    if "item_count" in df.columns:
-        df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
+    df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
     df = df[df["avg_price"] > 0].copy()
 
-    if "item_id" in df.columns:
-        for item in df["item_id"].unique():
-            mask = df["item_id"] == item
-            if mask.sum() < 10:
-                continue
-            lower = df.loc[mask, "avg_price"].quantile(0.005)
-            upper = df.loc[mask, "avg_price"].quantile(0.995)
-            if pd.notna(lower) and pd.notna(upper) and upper > lower:
-                df.loc[mask, "avg_price"] = df.loc[mask, "avg_price"].clip(lower, upper)
+    for item in df["item_id"].unique():
+        mask = df["item_id"] == item
+        if mask.sum() < 10:
+            continue
+        lower = df.loc[mask, "avg_price"].quantile(0.005)
+        upper = df.loc[mask, "avg_price"].quantile(0.995)
+        if pd.notna(lower) and pd.notna(upper) and upper > lower:
+            df.loc[mask, "avg_price"] = df.loc[mask, "avg_price"].clip(lower, upper)
 
-    df = df.sort_values(["item_id", "city", "timestamp"]).reset_index(drop=True)
-    return df
+    return df.sort_values(["item_id", "city", "timestamp"]).reset_index(drop=True)
 
 
 def save_to_csv(df: pd.DataFrame, name: str) -> str:
@@ -279,8 +250,7 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
     gain = delta.clip(lower=0).rolling(period).mean()
     loss = (-delta.clip(upper=0)).rolling(period).mean()
     rs = gain / loss.replace(0, np.nan)
-    rsi = 100 - (100 / (1 + rs))
-    return rsi.fillna(50)
+    return (100 - (100 / (1 + rs))).fillna(50)
 
 
 def build_features(df: pd.DataFrame) -> pd.DataFrame:
@@ -324,8 +294,8 @@ 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)
 
-    # Hedef: 4 bucket sonraki log getiri (time_scale=6h → 4*6=24h)
-    df["target_return_24h"] = df.groupby(group_cols)["log_price"].shift(-4)
+    # 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
 
     return df
 
@@ -347,6 +317,10 @@ FEATURE_COLS = [
 
 
 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()
 
@@ -356,22 +330,22 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
 
     df = df.dropna(subset=["target_return_24h", "lag_1h", "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:
+        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:
         df["ma_48h"] = df["ma_48h"].fillna(df["ma_24h"])
     if "ma_24h" in df.columns:
         df["ma_24h"] = df["ma_24h"].fillna(df["lag_24h"])
-    if "ma_12h" in df.columns:
-        df["ma_12h"] = df["ma_12h"].fillna(df.get("lag_12h", df["lag_24h"]))
-    if "ma_6h" in df.columns:
-        df["ma_6h"] = df["ma_6h"].fillna(df.get("lag_6h", df["lag_24h"]))
-    if "lag_3h" in df.columns:
-        df["lag_3h"] = df["lag_3h"].fillna(df.get("lag_6h", df["lag_24h"]))
-    if "lag_6h" in df.columns:
-        df["lag_6h"] = df["lag_6h"].fillna(df.get("lag_12h", df["lag_24h"]))
-    if "lag_12h" in df.columns:
-        df["lag_12h"] = df["lag_12h"].fillna(df["lag_24h"])
 
     for chg in ["chg_1h", "chg_6h", "chg_12h", "chg_24h"]:
         if chg in df.columns:
@@ -385,17 +359,15 @@ 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 DÜZELTME: target clip çok daha dar
-    if len(model_df) > 100:
-        lower = model_df["target_return_24h"].quantile(TARGET_CLIP_LOWER_Q)
-        upper = model_df["target_return_24h"].quantile(TARGET_CLIP_UPPER_Q)
-        model_df["target_return_24h"] = model_df["target_return_24h"].clip(
-            max(lower, MIN_LOG_RETURN), min(upper, MAX_LOG_RETURN)
-        )
+    # KRİTİK: Target zaten baz puan (×10000). Şimdi ±1500 bp (≈ ±0.15 log) sınırı
+    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)
 
     X = model_df[FEATURE_COLS].astype("float64")
     y = model_df["target_return_24h"].astype("float64")
-    meta = model_df[["item_id", "city", "timestamp", "avg_price", "target_return_24h"]].copy()
+    meta = model_df[["item_id", "city", "timestamp", "avg_price"]].copy()
+    meta["target_log_return"] = model_df["target_return_24h"] / TARGET_SCALE
 
     return X, y, meta
 
@@ -405,32 +377,38 @@ 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.")
+        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:]
 
-    # KRİTİK DÜZELTME: daha güçlü regülarizasyon → overfit önleme
+    # Regularizasyon DENGELİ — overfit değil, underfit de değil
     model = lgb.LGBMRegressor(
         objective="regression",
         metric="mae",
         boosting_type="gbdt",
-        num_leaves=15,              # 31 → 15
-        max_depth=6,                # eklendi
-        min_child_samples=50,       # eklendi
-        learning_rate=0.03,         # 0.05 → 0.03
-        n_estimators=400,
-        feature_fraction=0.7,
-        bagging_fraction=0.7,
+        num_leaves=31,
+        max_depth=8,
+        min_child_samples=20,
+        learning_rate=0.05,
+        n_estimators=600,
+        feature_fraction=0.8,
+        bagging_fraction=0.8,
         bagging_freq=5,
-        reg_alpha=0.1,              # L1
-        reg_lambda=1.0,             # L2
+        reg_alpha=0.0,
+        reg_lambda=0.1,
         verbose=-1,
         random_state=42,
         n_jobs=-1,
     )
 
     callbacks = [
-        lgb.early_stopping(stopping_rounds=30, verbose=False),
+        lgb.early_stopping(stopping_rounds=50, verbose=False),
         lgb.log_evaluation(period=0),
     ]
 
@@ -441,15 +419,17 @@ 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.")
+
     return model
 
 
 def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame) -> pd.DataFrame:
     """
-    KRİTİK DÜZELTME:
-    1. Ham tahmin clip'lenir (aşırı değerleri engelle).
-    2. Tahminin mutlak değeri çok küçükse "belirsiz" işaretlenir.
-    3. exp() güvenli aralıkta uygulanır.
+    Ham tahmin baz puan cinsinden → log getiriye çevir → clip → exp.
     """
     if latest_features.empty or model is None:
         return pd.DataFrame()
@@ -459,27 +439,51 @@ def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame)
         print(f"Eksik özellikler: {missing}")
         return pd.DataFrame()
 
-    X_pred = latest_features[FEATURE_COLS].astype("float64").dropna()
-    if X_pred.empty:
+    # 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:
+        if col in X_pred.columns:
+            X_pred[col] = np.log1p(X_pred[col].clip(lower=1.0))
+
+    for chg in ["chg_1h", "chg_6h", "chg_12h", "chg_24h"]:
+        if chg in X_pred.columns:
+            X_pred[chg] = X_pred[chg].fillna(0.0)
+
+    X_pred["rsi_14"] = X_pred["rsi_14"].fillna(50.0)
+    X_pred["volatility_24h"] = X_pred["volatility_24h"].fillna(0.0)
+    X_pred["volume_ma_24h"] = X_pred["volume_ma_24h"].fillna(0.0)
+    X_pred["volume_ratio"] = X_pred["volume_ratio"].fillna(1.0)
+    X_pred["city_price_deviation"] = X_pred["city_price_deviation"].fillna(0.0)
+
+    X_ready = X_pred[FEATURE_COLS].astype("float64").dropna()
+    if X_ready.empty:
         return pd.DataFrame()
 
-    raw_preds = model.predict(X_pred)
+    raw_preds_bp = model.predict(X_ready)  # baz puan
+    raw_preds_log = raw_preds_bp / TARGET_SCALE  # log getiri
 
-    # Ham tahmini güvenli aralığa clip'le
-    clipped_preds = np.clip(raw_preds, MIN_LOG_RETURN, MAX_LOG_RETURN)
+    # Tahmin çeşitliliği kontrolü
+    pred_std = np.std(raw_preds_log)
+    if pred_std < 1e-5:
+        print(f"⚠️ UYARI: Tüm tahminler aynı (std={pred_std:.8f}).")
 
-    # Yüzdeye çevir
-    pred_return_pct = (np.exp(clipped_preds) - 1) * 100
+    # Aşırı değerleri clip'le
+    clipped_log = np.clip(raw_preds_log, MIN_LOG_RETURN, MAX_LOG_RETURN)
 
-    result = latest_features.loc[X_pred.index, ["item_id", "city", "avg_price", "item_count", "volatility_24h", "rsi_14", "volume_ratio"]].copy()
-    result["raw_log_pred"] = raw_preds
-    result["clipped_log_pred"] = clipped_preds
-    result["predicted_log_return_24h"] = clipped_preds
-    result["predicted_return_pct"] = pred_return_pct
-    result["predicted_price_24h"] = result["avg_price"] * np.exp(clipped_preds)
+    pred_return_pct = (np.exp(clipped_log) - 1) * 100
 
-    # Belirsizlik göstergesi: |tahmin| < eşik ise "belirsiz"
-    result["is_uncertain"] = np.abs(clipped_preds) < LOW_CONFIDENCE_THRESHOLD
+    result = X_pred.loc[X_ready.index, ["item_id", "city", "avg_price", "item_count",
+                                         "volatility_24h", "rsi_14", "volume_ratio"]].copy()
+    result["raw_log_pred"] = raw_preds_log
+    result["clipped_log_pred"] = clipped_log
+    result["predicted_log_return_24h"] = clipped_log
+    result["predicted_return_pct"] = pred_return_pct
+    result["predicted_price_24h"] = result["avg_price"] * np.exp(clipped_log)
+    result["is_uncertain"] = np.abs(clipped_log) < LOW_CONFIDENCE_THRESHOLD
 
     return result
 
@@ -495,9 +499,8 @@ 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:
-        return {"error": "Backtest için yeterli zaman noktası yok."}
+        return {"error": "Yeterli zaman noktası yok."}
 
     test_size = len(unique_times) // (n_splits + 1)
     results = []
@@ -508,7 +511,6 @@ 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 - 8
         if train_end_idx <= 0:
             continue
@@ -529,31 +531,24 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
             continue
 
         model = lgb.LGBMRegressor(
-            objective="regression",
-            metric="mae",
-            num_leaves=15,
-            max_depth=6,
-            min_child_samples=50,
-            learning_rate=0.03,
-            n_estimators=300,
-            reg_alpha=0.1,
-            reg_lambda=1.0,
-            verbose=-1,
-            random_state=42,
-            n_jobs=-1,
+            objective="regression", metric="mae",
+            num_leaves=31, max_depth=8, min_child_samples=20,
+            learning_rate=0.05, n_estimators=400,
+            reg_lambda=0.1, verbose=-1, random_state=42, n_jobs=-1,
         )
         model.fit(X_train, y_train)
 
-        raw_preds = model.predict(X_test)
-        preds = np.clip(raw_preds, MIN_LOG_RETURN, MAX_LOG_RETURN)
+        preds_bp = model.predict(X_test)
+        preds = np.clip(preds_bp / TARGET_SCALE, MIN_LOG_RETURN, MAX_LOG_RETURN)
+        y_test_log = y_test / TARGET_SCALE
 
-        mae = mean_absolute_error(y_test, preds)
-        rmse = np.sqrt(mean_squared_error(y_test, preds))
-        direction_correct = np.mean((y_test > 0) == (preds > 0))
+        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))
 
-        baseline_preds = np.zeros_like(y_test)
-        baseline_mae = mean_absolute_error(y_test, baseline_preds)
-        baseline_rmse = np.sqrt(mean_squared_error(y_test, baseline_preds))
+        baseline_preds = np.zeros_like(y_test_log)
+        baseline_mae = mean_absolute_error(y_test_log, baseline_preds)
+        baseline_rmse = np.sqrt(mean_squared_error(y_test_log, baseline_preds))
 
         results.append({
             "split": i + 1,
@@ -569,11 +564,11 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
         test_meta = meta_test.copy()
         test_meta["predicted_return"] = preds
-        test_meta["actual_return"] = y_test.values
+        test_meta["actual_return"] = y_test_log.values
         all_predictions.append(test_meta)
 
     if not results:
-        return {"error": "Backtest tamamlanamadı (yeterli veri yok)."}
+        return {"error": "Backtest tamamlanamadı."}
 
     if all_predictions:
         sim_df = pd.concat(all_predictions)
@@ -583,12 +578,10 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
         sim_trades = sim_df[sim_df["trade_signal"]].copy()
 
         if len(sim_trades) > 0:
-            avg_net_return = sim_trades["net_return"].mean()
-            win_rate = (sim_trades["net_return"] > 0).mean()
             simulation = {
                 "total_trades": int(len(sim_trades)),
-                "avg_net_return_per_trade_pct": round(float(avg_net_return * 100), 4),
-                "win_rate_pct": round(float(win_rate * 100), 2),
+                "avg_net_return_per_trade_pct": round(float(sim_trades["net_return"].mean() * 100), 4),
+                "win_rate_pct": round(float((sim_trades["net_return"] > 0).mean() * 100), 2),
                 "profitable_trades": int((sim_trades["net_return"] > 0).sum()),
             }
         else:
@@ -596,11 +589,7 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
     else:
         simulation = {}
 
-    return {
-        "results": results,
-        "simulation": simulation,
-        "n_splits_completed": len(results),
-    }
+    return {"results": results, "simulation": simulation, "n_splits_completed": len(results)}
 
 
 # ---------------------------------------------------------------------------
@@ -617,23 +606,19 @@ class DataPipeline:
         self.last_update = None
         self.status_message = "Veri yüklenmedi. 'Verileri Yenile' butonuna basın."
         self._backtest_cache = None
-        self.data_source = "PUBLIC_API_EUROPE"
 
         if _HAS_JOBLIB and os.path.exists(MODEL_PATH):
             try:
                 self.model = joblib.load(MODEL_PATH)
-                self.status_message = "Kayıtlı model yüklendi. 'Verileri Yenile' ile güncelleyin."
-                print("Kayıtlı model yüklendi.")
+                self.status_message = "Kayıtlı model yüklendi."
             except Exception as e:
                 print(f"Model yükleme hatası: {e}")
 
-    def fetch_data(self, item_ids: List[str] = None, cities: List[str] = None):
-        if item_ids is None:
-            item_ids = ITEM_IDS
-        if cities is None:
-            cities = CITIES
+    def fetch_data(self, item_ids=None, cities=None):
+        item_ids = item_ids or ITEM_IDS
+        cities = cities or CITIES
 
-        self.status_message = f"Public API ({API_BASE}) üzerinden veri çekiliyor..."
+        self.status_message = "Public API'den veri çekiliyor..."
         ok, msg = check_api_health()
         if not ok:
             self.status_message = f"API erişilemiyor: {msg}"
@@ -647,15 +632,12 @@ class DataPipeline:
             return
 
         if hist.empty:
-            self.status_message = "Tarihsel veri alınamadı. Public API geçici olarak yanıt vermiyor olabilir."
+            self.status_message = "Tarihsel veri alınamadı."
             return
 
         self.history_df = clean_market_data(hist)
         self.prices_df = prices
-        self.status_message = (
-            f"✓ Public API'den alındı: {len(self.history_df)} satır tarihsel, "
-            f"{len(self.prices_df)} anlık fiyat. (time-scale={HISTORY_TIME_SCALE}h)"
-        )
+        self.status_message = f"✓ {len(self.history_df)} satır tarihsel, {len(self.prices_df)} anlık."
 
         save_to_csv(self.history_df, "history")
         save_to_csv(self.prices_df, "prices")
@@ -670,11 +652,13 @@ class DataPipeline:
 
         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}). "
-                f"Toplam tarihsel satır: {len(self.featured_df)}. "
-                f"HISTORY_TIME_SCALE=1 deneyin."
-            )
+            self.status_message = f"Yetersiz örnek: {len(X)} (min {MIN_TRAIN_SAMPLES})"
+            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."
             return False
 
         self.model = train_global_model(X, y)
@@ -682,17 +666,19 @@ 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."
+        else:
+            self.status_message = f"Model eğitildi ({len(X)} örnek, pred_std={pred_std:.1f} bp)."
+
         if _HAS_JOBLIB:
             try:
                 joblib.dump(self.model, MODEL_PATH)
-                self.status_message = (
-                    f"Model eğitildi ve kaydedildi ({len(X)} örnek). "
-                    f"Tahminler ±%15 aralığına sınırlandırıldı."
-                )
             except Exception as e:
-                self.status_message = f"Model eğitildi ancak kaydedilemedi: {e}"
-        else:
-            self.status_message = f"Model eğitildi ({len(X)} örnek). Tahminler ±%15 aralığına sınırlandırıldı."
+                print(f"Kaydetme hatası: {e}")
 
         self.last_update = dt.datetime.now()
         return True
@@ -720,12 +706,10 @@ class DataPipeline:
         else:
             preds["spread"] = np.nan
 
-        # Gelişmiş güvenilirlik: volatilite + RSI aşırı bölge + volume
         vol_score = (1.0 - preds["volatility_24h"].clip(0, 0.2) / 0.2).fillna(0.5)
         rsi_penalty = ((preds["rsi_14"] - 50).abs() / 50).clip(0, 1).fillna(0.5) * 0.2
         vol_ratio_score = preds["volume_ratio"].clip(0, 2).fillna(1.0) / 2
         base_conf = vol_score * 0.6 + vol_ratio_score * 0.4 - rsi_penalty
-        # Belirsiz tahminleri cezalandır
         certainty_penalty = preds["is_uncertain"].astype(float) * 0.4
         preds["confidence"] = (base_conf - certainty_penalty).clip(0, 1).fillna(0.3)
 
@@ -744,33 +728,29 @@ pipeline = DataPipeline()
 
 
 # ---------------------------------------------------------------------------
-# GRADIO YARDIMCI FONKSİYONLARI
+# GRADIO YARDIMCILARI
 # ---------------------------------------------------------------------------
 
 
 def get_dashboard_metrics():
     if pipeline.featured_df.empty:
         return pd.DataFrame({
-            "Metrik": ["Durum", "Veri Kaynağı", "Model Durumu"],
-            "Değer": [
-                "Veri yok - 'Verileri Yenile' butonuna tıklayın.",
-                "Public AODP API (europe)",
-                "Kayıtlı model var" if pipeline.model is not None else "Yok",
-            ]
+            "Metrik": ["Durum", "Veri Kaynağı", "Model"],
+            "Değer": ["Veri yok.", "Public AODP API (europe)", "Yok" if pipeline.model is None else "Yüklü"],
         })
 
     df = pipeline.featured_df
     metrics = {
-        "Veri Kaynağı": "Public AODP API (europe.albion-online-data.com)",
-        "Time-scale": f"{HISTORY_TIME_SCALE} saat",
+        "Veri Kaynağı": "Public AODP API (europe)",
+        "Time-scale": f"{HISTORY_TIME_SCALE}h",
         "Toplam Gözlem": len(df),
         "Ürün Sayısı": df["item_id"].nunique(),
         "Şehir Sayısı": df["city"].nunique(),
         "Tarih Aralığı": f"{df['timestamp'].min().date()} - {df['timestamp'].max().date()}",
         "Ortalama Fiyat": f"{df['avg_price'].mean():.0f} silver",
-        "Ortalama Hacim": f"{df['item_count'].mean():.1f}",
         "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"])
@@ -796,22 +776,16 @@ 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["Likidite"] = pd.cut(
-        latest["item_count"],
-        bins=[-1, 10, 50, 200, np.inf],
-        labels=["Düşük", "Orta", "İyi", "Yüksek"]
-    ).astype(str)
+    latest["Likidite"] = pd.cut(latest["item_count"], bins=[-1, 10, 50, 200, np.inf],
+                                 labels=["Düşük", "Orta", "İyi", "Yüksek"]).astype(str)
 
-    cols = ["Ürün", "Şehir", "Mevcut Fiyat", "Hacim", "Spread", "Likidite"]
-    return latest[cols].sort_values("Hacim", ascending=False).head(100)
+    return latest[["Ürün", "Şehir", "Mevcut Fiyat", "Hacim", "Spread", "Likidite"]].sort_values("Hacim", ascending=False).head(100)
 
 
 def get_prediction_table():
     preds = pipeline.get_latest_predictions()
     if preds.empty:
-        return pd.DataFrame({
-            "Bilgi": ["Tahmin üretilemedi. Veri çekip model eğitin."]
-        })
+        return pd.DataFrame({"Bilgi": ["Tahmin üretilemedi."]})
 
     preds = preds.copy()
     preds["Ürün"] = preds["item_id"].apply(item_display_name)
@@ -822,58 +796,45 @@ def get_prediction_table():
     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)
-    # Belirsiz tahminleri işaretle
+    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"
-    ]
+    cols = ["Ürün", "Şehir", "Mevcut Fiyat", "Tahmini Fiyat (24s)",
+            "Tahmini Deği��im %", "Güvenilirlik", "Spread", "Likidite",
+            "Net Getiri % (maliyet sonrası)", "Not"]
     return preds[cols].sort_values("Tahmini Değişim %", ascending=False)
 
 
 def get_arbitrage_table():
     if pipeline.prices_df.empty:
-        return pd.DataFrame({"Bilgi": ["Anlık fiyat verisi yok."]})
+        return pd.DataFrame({"Bilgi": ["Anlık fiyat yok."]})
 
     prices = pipeline.prices_df.copy()
     prices["sell_price_min"] = pd.to_numeric(prices["sell_price_min"], errors="coerce").astype("float64")
     prices["buy_price_max"] = pd.to_numeric(prices["buy_price_max"], errors="coerce").astype("float64")
     prices = prices[prices["sell_price_min"] > 0]
-
     if prices.empty:
-        return pd.DataFrame({"Bilgi": ["Geçerli anlık fiyat yok."]})
+        return pd.DataFrame({"Bilgi": ["Geçerli fiyat yok."]})
 
     buy = prices.loc[prices.groupby("item_id")["sell_price_min"].idxmin()][["item_id", "city", "sell_price_min"]]
     buy.columns = ["item_id", "buy_city", "buy_price"]
-
     sell = prices.loc[prices.groupby("item_id")["buy_price_max"].idxmax()][["item_id", "city", "buy_price_max"]]
     sell.columns = ["item_id", "sell_city", "sell_price"]
 
     arb = buy.merge(sell, on="item_id")
     arb = arb[arb["sell_price"] > arb["buy_price"]].copy()
-
     if arb.empty:
-        return pd.DataFrame({"Bilgi": ["Kârlı arbitraj fırsatı bulunamadı."]})
+        return pd.DataFrame({"Bilgi": ["Kârlı arbitraj yok."]})
 
     arb["brüt_kâr"] = arb["sell_price"] - arb["buy_price"]
-    arb["toplam_maliyet"] = (
-        arb["buy_price"] * SETUP_FEE_RATE
-        + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
-    )
+    arb["toplam_maliyet"] = arb["buy_price"] * SETUP_FEE_RATE + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
     arb["net_kâr"] = arb["brüt_kâr"] - arb["toplam_maliyet"]
     arb["kâr_marjı_%"] = (arb["net_kâr"] / arb["buy_price"]) * 100
-
     arb = arb[arb["net_kâr"] > 0].sort_values("kâr_marjı_%", ascending=False)
 
     if arb.empty:
-        return pd.DataFrame({"Bilgi": ["İşlem maliyetleri sonrası kârlı arbitraj yok."]})
+        return pd.DataFrame({"Bilgi": ["Maliyetler sonrası kârlı arbitraj yok."]})
 
     arb["Ürün"] = arb["item_id"].apply(item_display_name)
     arb["Alış Şehri"] = arb["buy_city"]
@@ -883,54 +844,38 @@ def get_arbitrage_table():
     arb["Net Kâr"] = arb["net_kâr"].round(0)
     arb["Kâr Marjı %"] = arb["kâr_marjı_%"].round(1)
 
-    cols = ["Ürün", "Alış Şehri", "Satış Şehri", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Kâr Marjı %"]
-    return arb[cols].head(50)
+    return arb[["Ürün", "Alış Şehri", "Satış Şehri", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Kâr Marjı %"]].head(50)
 
 
 def get_model_performance_plot():
     if pipeline.model is None:
-        return go.Figure().update_layout(
-            title="Model eğitilmedi - Lütfen 'Verileri Yenile' butonuna tıklayın",
-            template="plotly_dark"
-        )
-
+        return go.Figure().update_layout(title="Model eğitilmedi", template="plotly_dark")
     try:
-        importance = pipeline.model.feature_importances_
-        feature_names = pipeline.model.feature_name_
-        df_imp = pd.DataFrame({"Özellik": feature_names, "Önem": importance}).sort_values("Önem", ascending=True).tail(20)
+        df_imp = pd.DataFrame({
+            "Özellik": pipeline.model.feature_name_,
+            "Önem": pipeline.model.feature_importances_,
+        }).sort_values("Önem", ascending=True).tail(20)
         fig = px.bar(df_imp, x="Önem", y="Özellik", orientation="h",
                      title="Feature Importance (Top 20)", template="plotly_dark")
         fig.update_layout(height=600)
         return fig
     except Exception as e:
-        return go.Figure().update_layout(title=f"Grafik hatası: {e}", template="plotly_dark")
+        return go.Figure().update_layout(title=f"Hata: {e}", template="plotly_dark")
 
 
 def get_backtest_outputs():
     bt = pipeline.get_backtest()
-
     if "error" in bt:
-        empty_fig = go.Figure().update_layout(title=f"Backtest hatası: {bt['error']}", template="plotly_dark")
-        return pd.DataFrame({"Bilgi": [bt["error"]]}), empty_fig, 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()
     fig.add_trace(go.Bar(name="Model MAE", x=results_df["split"], y=results_df["mae"], marker_color="cyan"))
     fig.add_trace(go.Bar(name="Baseline MAE", x=results_df["split"], y=results_df["baseline_mae"], marker_color="gray"))
-    fig.update_layout(
-        title="Walk-Forward Backtest: MAE Karşılaştırması",
-        xaxis_title="Split",
-        yaxis_title="MAE (log getiri)",
-        barmode="group",
-        template="plotly_dark",
-    )
-
-    if bt.get("simulation"):
-        sim_df = pd.DataFrame([bt["simulation"]])
-    else:
-        sim_df = pd.DataFrame()
+    fig.update_layout(title="Walk-Forward: MAE", xaxis_title="Split", yaxis_title="MAE (log getiri)",
+                      barmode="group", template="plotly_dark")
 
+    sim_df = pd.DataFrame([bt["simulation"]]) if bt.get("simulation") else pd.DataFrame()
     return results_df, fig, sim_df
 
 
@@ -941,14 +886,14 @@ def list_csv_files() -> pd.DataFrame:
             if fname.endswith(".csv"):
                 fpath = os.path.join(DATA_DIR, fname)
                 try:
-                    size_kb = round(os.path.getsize(fpath) / 1024, 2)
-                    mtime = dt.datetime.fromtimestamp(os.path.getmtime(fpath)).strftime("%Y-%m-%d %H:%M:%S")
-                    rows.append({"Dosya": fname, "Boyut (KB)": size_kb, "Son Değişiklik": mtime})
+                    rows.append({
+                        "Dosya": fname,
+                        "Boyut (KB)": round(os.path.getsize(fpath) / 1024, 2),
+                        "Son Değişiklik": dt.datetime.fromtimestamp(os.path.getmtime(fpath)).strftime("%Y-%m-%d %H:%M:%S"),
+                    })
                 except OSError:
                     continue
-    if not rows:
-        return pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
-    return pd.DataFrame(rows)
+    return pd.DataFrame(rows) if rows else pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
 
 
 def refresh_data_ui():
@@ -957,83 +902,49 @@ def refresh_data_ui():
         if not pipeline.featured_df.empty:
             pipeline.train_model()
     except Exception as e:
-        pipeline.status_message = f"Beklenmeyen hata: {e}"
-        print(f"Refresh hatası: {e}")
+        pipeline.status_message = f"Hata: {e}"
         import traceback
         traceback.print_exc()
 
     try:
         bt_table, bt_fig, sim_table = get_backtest_outputs()
-    except Exception as e:
-        bt_table = pd.DataFrame({"Bilgi": [f"Backtest hatası: {e}"]})
+    except Exception:
+        bt_table, sim_table = pd.DataFrame(), pd.DataFrame()
         bt_fig = go.Figure().update_layout(title="Backtest hatası", template="plotly_dark")
-        sim_table = pd.DataFrame()
-
-    try:
-        dash = get_dashboard_metrics()
-    except Exception as e:
-        dash = pd.DataFrame({"Bilgi": [f"Hata: {e}"]})
-
-    try:
-        ana = get_analysis_table()
-    except Exception as e:
-        ana = pd.DataFrame({"Bilgi": [f"Hata: {e}"]})
-
-    try:
-        pred = get_prediction_table()
-    except Exception as e:
-        pred = pd.DataFrame({"Bilgi": [f"Hata: {e}"]})
-
-    try:
-        arb = get_arbitrage_table()
-    except Exception as e:
-        arb = pd.DataFrame({"Bilgi": [f"Hata: {e}"]})
-
-    try:
-        perf = get_model_performance_plot()
-    except Exception as e:
-        perf = go.Figure().update_layout(title=f"Hata: {e}", template="plotly_dark")
 
-    try:
-        csv_df = list_csv_files()
-    except Exception:
-        csv_df = pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
+    def _safe(fn, default):
+        try:
+            return fn()
+        except Exception as e:
+            return pd.DataFrame({"Bilgi": [f"Hata: {e}"]}) if default is None else default
 
     return (
         pipeline.status_message,
-        dash,
-        ana,
-        pred,
-        arb,
-        perf,
-        bt_table,
-        bt_fig,
-        sim_table,
-        csv_df,
+        _safe(get_dashboard_metrics, pd.DataFrame()),
+        _safe(get_analysis_table, pd.DataFrame()),
+        _safe(get_prediction_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,
+        _safe(list_csv_files, pd.DataFrame()),
     )
 
 
 def initial_load():
-    try:
-        dash = get_dashboard_metrics()
-    except Exception:
-        dash = pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})
-
-    try:
-        csv_df = list_csv_files()
-    except Exception:
-        csv_df = pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
+    def _safe(fn, default):
+        try:
+            return fn()
+        except Exception:
+            return default
 
     return (
-        dash,
-        pd.DataFrame(),
-        pd.DataFrame(),
+        _safe(get_dashboard_metrics, pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})),
+        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="Verileri yenilemek için butona tıklayın", template="plotly_dark"),
+        go.Figure().update_layout(title="Veri gerekli", template="plotly_dark"),
         pd.DataFrame(),
-        go.Figure().update_layout(title="Backtest için veri gerekli", template="plotly_dark"),
-        pd.DataFrame(),
-        csv_df,
+        _safe(list_csv_files, pd.DataFrame()),
     )
 
 
@@ -1050,10 +961,9 @@ 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.*
 
-        **Veri kaynağı:** Public Albion Online Data Project API (`europe.albion-online-data.com`)
-        **Tahmin sınırı:** ±%15 (aşırı tahminler engellendi)
+        **Tahmin sınırı:** ±%15 · **Hedef ölçeği:** baz puan (×10000)
 
-        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir ve kesin kazanç garantisi sunmaz. Geçmiş performans gelecek sonuçların göstergesi değildir.
+        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir ve kesin kazanç garantisi sunmaz.
         """
     )
 
@@ -1062,96 +972,56 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         status_text = gr.Textbox(label="Durum", interactive=False, scale=2, value=pipeline.status_message)
 
     with gr.Tabs():
-
         with gr.TabItem("📊 Dashboard"):
-            dashboard_table = gr.Dataframe(label="Özet Metrikler", interactive=False, wrap=True)
+            dashboard_table = gr.Dataframe(label="Özet", interactive=False, wrap=True)
             gr.Markdown(
-                "### Tahmin Kalibrasyonu\n"
-                "- Model log getiri tahminleri **±0.15 log birimi** (yaklaşık ±%16) ile sınırlandırılmıştır.\n"
-                "- Bu aralığın dışındaki ham tahminler `clip`lenir.\n"
-                "- Tahmin mutlak değeri < 0.02 ise **belirsiz** olarak işaretlenir.\n"
-                "- Güvenilirlik; volatilite, RSI aşırı bölge ve hacim oranına göre hesaplanır.\n\n"
+                "### 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"
                 "### Riskler\n"
-                "- Model tahminleri **olasılıksaldır**, kesin değildir.\n"
-                "- Backtest sonuçları geçmiş performansı yansıtır; gelecek performansı garanti etmez.\n"
-                "- Spread ve likidite düşükse gerçekleşme fiyatı tahminden sapabilir.\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"
             )
 
         with gr.TabItem("📦 100 Ürün Analizi"):
-            analysis_table = gr.Dataframe(label="Ürün Analizi (En yüksek hacimli 100 ürün)", interactive=False)
+            analysis_table = gr.Dataframe(label="Ürün Analizi", interactive=False)
 
         with gr.TabItem("🔮 24 Saatlik Fiyat Tahmini"):
-            prediction_table = gr.Dataframe(label="Tahminler (24 saatlik log getiri modeli)", interactive=False)
-            gr.Markdown(
-                "*Net getiri %2.5 setup + %8 vergi düşülerek hesaplanır. "
-                "**Not** sütunundaki ⚠️ Belirsiz işareti, modelin sinyal üretmediği durumları gösterir. "
-                "Bu tahminler garanti değildir.*"
-            )
+            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("🚚 Şehirler Arası Arbitraj"):
-            arbitrage_table = gr.Dataframe(label="Arbitraj Fırsatları (işlem maliyetleri dahil)", interactive=False)
-            gr.Markdown(
-                "*Net kâr; alışta %2.5 setup fee, satışta %2.5 setup + %8 transaction tax düşülerek hesaplanmıştır. "
-                "Seyahat maliyeti ve zaman riski dahil değildir.*"
-            )
+        with gr.TabItem("🚚 Arbitraj"):
+            arbitrage_table = gr.Dataframe(label="Arbitraj Fırsatları", interactive=False)
 
         with gr.TabItem("📈 Model Performansı"):
             performance_plot = gr.Plot(label="Feature Importance")
 
-        with gr.TabItem("🧪 Walk-forward Backtest"):
+        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="İşlem Simülasyonu (maliyetler sonrası)", interactive=False)
-            gr.Markdown(
-                "*Walk-forward backtest kronolojik split kullanır; purge ve embargo uygulanır. "
-                "Baseline 'fiyat değişmez' varsayımıdır. Simülasyon yalnızca modelin güven eşiğinin üzerinde "
-                "pozitif getiri öngördüğü işlemleri içerir.*"
-            )
+            simulation_table = gr.Dataframe(label="Simülasyon", interactive=False)
 
         with gr.TabItem("🗄️ Veri Yönetimi"):
-            gr.Markdown(
-                "Veriler `gos_hawk_data/` dizininde CSV olarak saklanır.\n\n"
-                "**API Kaynağı:** Public AODP API — `europe.albion-online-data.com/api/v2`\n"
-                "**Endpoint'ler:** `/stats/prices/` (anlık), `/stats/history/` (tarihsel)\n"
-                "**Model dosyası:** `gos_hawk_data/models/gos_hawk_model.pkl`\n"
-            )
-            csv_files = gr.Dataframe(
-                label="Kayıtlı CSV Dosyaları (Yenile butonuna basınca güncellenir)",
-                interactive=False,
-                headers=["Dosya", "Boyut (KB)", "Son Değişiklik"],
-            )
+            gr.Markdown("**API:** `europe.albion-online-data.com/api/v2`\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"])
 
     refresh_btn.click(
         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,
-        ],
+        outputs=[status_text, dashboard_table, analysis_table, prediction_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, arbitrage_table,
+                 performance_plot, backtest_table, backtest_plot, simulation_table, csv_files],
     )