Update app.py

app.py

@@ -1,6 +1,6 @@
 # app.py
-# GOSHAWK ALBION MARKET AI
-# Kalite ayrımı + uzun vadeli trend (7/14 gün) + alış-satış spread feature'ları
+# GOSHAWK ALBION MARKET AI v3.0
+# 24h + 3 aylık (90 gün) çok ufuklu tahmin
 
 import os
 import time
@@ -15,7 +15,7 @@ import plotly.graph_objects as go
 import plotly.express as px
 
 import lightgbm as lgb
-from sklearn.metrics import accuracy_score
+from sklearn.metrics import accuracy_score, mean_absolute_error
 
 import gradio as gr
 
@@ -38,10 +38,6 @@ CITIES = [
     "Martlock", "Thetford", "Caerleon",
 ]
 
-# Kalite seviyeleri (1=Normal, 2=Good, 3=Outstanding, 4=Excellent, 5=Masterpiece)
-QUALITIES = ["1", "2", "3", "4", "5"]
-
-# Kalite kodları → insan-okunur
 QUALITY_NAMES = {1: "Normal", 2: "Good", 3: "Outstanding", 4: "Excellent", 5: "Masterpiece"}
 
 _ITEM_POOL = [
@@ -108,32 +104,36 @@ 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")
+MODEL_PATH_24H = os.path.join(MODEL_DIR, "gos_hawk_24h.pkl")
+MODEL_PATH_90D = os.path.join(MODEL_DIR, "gos_hawk_90d.pkl")
 
 MIN_TRAIN_SAMPLES = 150
 REQUEST_TIMEOUT = 60
 MAX_RETRIES = 3
 RETRY_BACKOFF = 2
 
-HISTORY_TIME_SCALE = 1
+HISTORY_TIME_SCALE = 6  # 6h — 3 aylık veri için saatlik çok ağır
 
-CLASS_DOWN = -0.03
-CLASS_UP = 0.03
+# 24h sınıflandırma
+CLASS_DOWN_24H = -0.03
+CLASS_UP_24H = 0.03
+TARGET_TOLERANCE_HOURS_24H = 12
 
-TARGET_TOLERANCE_HOURS = 12
+# 90 gün (3 ay) sınıflandırma — daha geniş sınırlar
+HORIZON_DAYS_90D = 90
+CLASS_DOWN_90D = -0.10
+CLASS_UP_90D = 0.10
+TARGET_TOLERANCE_HOURS_90D = 72  # 3 gün tolerans
 
-# Dip alım
+# Dip sinyali
 DIP_RSI_MAX = 40.0
 DIP_PERCENTILE_MAX = 0.25
 DIP_MIN_VOLUME_RATIO = 1.0
 DIP_MIN_PREDICTED_PCT = -1.0
 DIP_MAX_SPREAD_PCT = 0.15
 
-# Uzun vadeli lag/chg pencereleri
-LONG_TERM_WINDOWS = [24, 168, 336]  # 1g, 7g, 14g
-
-# Feature kolonları (spread + uzun vadeli dahil)
-FEATURE_COLS = [
+# 24h feature'lar
+FEATURE_COLS_24H = [
     "hour", "dayofweek",
     "lag_24h_log", "lag_168h_log", "lag_336h_log",
     "chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h",
@@ -145,13 +145,27 @@ FEATURE_COLS = [
     "item_code", "city_code",
 ]
 
+# 90d feature'lar — daha uzun vadeli
+FEATURE_COLS_90D = [
+    "month", "dayofweek",
+    "lag_720h_log", "lag_1440h_log",  # 30g, 60g
+    "chg_336h", "chg_720h", "chg_1440h",  # 14g, 30g, 60g değişim
+    "rsi_14", "volatility_24h", "volatility_168h",
+    "volume_ratio",
+    "ma_168h_ratio", "ma_720h_ratio",  # 7g, 30g MA oranı
+    "trend_slope_30d",  # 30 günlük lineer trend eğimi
+    "city_price_deviation",
+    "spread_pct", "buy_sell_ratio", "qual_code",
+    "item_code", "city_code",
+]
+
 # ---------------------------------------------------------------------------
 # PUBLIC API
 # ---------------------------------------------------------------------------
 
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
-    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/2.0", "Accept": "application/json"}
+    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/3.0", "Accept": "application/json"}
     for attempt in range(MAX_RETRIES):
         try:
             resp = requests.get(url, params=params, headers=headers, timeout=REQUEST_TIMEOUT)
@@ -164,18 +178,18 @@ def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
                 time.sleep(RETRY_BACKOFF * (attempt + 1))
                 continue
             else:
-                print(f"API hatası: {resp.status_code} - {url}")
+                print(f"API: {resp.status_code} - {url}")
                 return None
         except requests.exceptions.Timeout:
-            print(f"Zaman aşımı: {url}")
+            print(f"Timeout: {url}")
         except requests.exceptions.RequestException as e:
-            print(f"İstek hatası: {e}")
+            print(f"Hata: {e}")
         time.sleep(RETRY_BACKOFF * (attempt + 1))
     return None
 
 
-def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1,2,3,4,5") -> pd.DataFrame:
-    """Anlık fiyatlar — tüm kaliteler."""
+def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1,2,3") -> pd.DataFrame:
+    """Anlık fiyatlar — Q1, Q2, Q3 yeterli (Q4/Q5 nadiren işlem görür)."""
     all_data = []
     for i in range(0, len(item_ids), 40):
         chunk = item_ids[i:i+40]
@@ -197,13 +211,15 @@ 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 = 1, qualities: str = "1,2,3,4,5") -> pd.DataFrame:
-    """Tarihsel fiyatlar — tüm kaliteler."""
+def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6,
+                  qualities: str = "1,2,3") -> pd.DataFrame:
+    """Tarihsel fiyatlar — 3 aylık tahmin için en az 3 ay veri gerekir."""
     all_records = []
     for i in range(0, len(item_ids), 15):
         chunk = item_ids[i:i+15]
         url = f"{API_BASE}/stats/history/{','.join(chunk)}.json"
-        params = {"locations": ",".join(cities), "qualities": qualities, "time-scale": time_scale}
+        params = {"locations": ",".join(cities), "qualities": qualities,
+                  "time-scale": time_scale}
         data = safe_request(url, params)
         if data:
             for entry in data:
@@ -254,7 +270,6 @@ def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
     df = df[df["avg_price"] > 0].copy()
     df = df.dropna(subset=["timestamp"]).copy()
 
-    # Kalite bazlı temizlik (item+city+quality bazında)
     for (item, qual) in df[["item_id", "quality"]].drop_duplicates().itertuples(index=False):
         mask = (df["item_id"] == item) & (df["quality"] == qual)
         if mask.sum() < 10:
@@ -274,7 +289,7 @@ def save_to_csv(df: pd.DataFrame, name: str) -> str:
     try:
         df.to_csv(path, index=False)
     except Exception as e:
-        print(f"CSV yazma hatası: {e}")
+        print(f"CSV hatası: {e}")
         return ""
     return path
 
@@ -292,11 +307,19 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
     return (100 - (100 / (1 + rs))).fillna(50)
 
 
+def _linear_trend_slope(y: np.ndarray) -> float:
+    """Basit lineer regresyon eğimi (log ölçek)."""
+    if len(y) < 5:
+        return 0.0
+    x = np.arange(len(y), dtype=float)
+    try:
+        slope = np.polyfit(x, y, 1)[0]
+        return float(slope)
+    except Exception:
+        return 0.0
+
+
 def build_features(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Kalite ayrımı + uzun vadeli trend + spread feature'ları.
-    group_cols = [item_id, city, quality] → kalite farkı artık karışmıyor.
-    """
     if df.empty:
         return df
 
@@ -309,24 +332,21 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
 
     df["hour"] = df["timestamp"].dt.hour
     df["dayofweek"] = df["timestamp"].dt.dayofweek
+    df["month"] = df["timestamp"].dt.month
     df["is_weekend"] = (df["dayofweek"] >= 5).astype(int)
     df["qual_code"] = df["quality"].astype(int)
 
-    # KRİTİK: kalite artık grup içinde
     group_cols = ["item_id", "city", "quality"]
-
     df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
 
-    # Uzun vadeli lag'ler
+    # Kısa vadeli (24h model)
     df["lag_24h_log"] = df.groupby(group_cols)["log_price"].shift(24)
     df["lag_168h_log"] = df.groupby(group_cols)["log_price"].shift(168)
     df["lag_336h_log"] = df.groupby(group_cols)["log_price"].shift(336)
 
-    # Değişimler
     for chg in [1, 6, 24, 168, 336]:
         df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
 
-    # MA oranları
     df["ma_24h_raw"] = df.groupby(group_cols)["avg_price"].transform(
         lambda x: x.rolling(24, min_periods=6).mean()
     )
@@ -337,82 +357,61 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     )
     df["ma_168h_ratio"] = df["ma_168h_raw"] / df["avg_price"].replace(0, np.nan) - 1.0
 
+    # Uzun vadeli (90d model)
+    df["lag_720h_log"] = df.groupby(group_cols)["log_price"].shift(720)   # 30g
+    df["lag_1440h_log"] = df.groupby(group_cols)["log_price"].shift(1440) # 60g
+
+    for chg in [720, 1440]:
+        df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
+
+    df["ma_720h_raw"] = df.groupby(group_cols)["avg_price"].transform(
+        lambda x: x.rolling(720, min_periods=72).mean()
+    )
+    df["ma_720h_ratio"] = df["ma_720h_raw"] / df["avg_price"].replace(0, np.nan) - 1.0
+
     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["volatility_168h"] = df.groupby(group_cols)["log_price"].transform(
+        lambda x: x.rolling(168, min_periods=24).std()
+    )
     df["volume_ma_24h"] = df.groupby(group_cols)["item_count"].transform(
         lambda x: x.rolling(24, min_periods=6).mean()
     )
     df["volume_ratio"] = df["item_count"] / df["volume_ma_24h"].replace(0, np.nan)
 
-    # Şehir fiyat farkı (aynı item+quality+timestamp içinde)
+    # 30 günlük lineer trend eğimi
+    df["trend_slope_30d"] = df.groupby(group_cols)["log_price"].transform(
+        lambda x: x.rolling(720, min_periods=72).apply(_linear_trend_slope, raw=True)
+    )
+
     city_avg = df.groupby(["item_id", "quality", "timestamp"])["avg_price"].transform("mean")
     df["city_price_deviation"] = (df["avg_price"] - city_avg) / city_avg.replace(0, np.nan)
 
-    # 7g 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
         )
     )
-
     df["is_downtrend"] = ((df["chg_6h"] < 0) & (df["chg_24h"] < 0)).astype(int)
 
-    # SPREAD feature'ları — prices_df'ten merge edilecek
-    # Şimdilik NaN, sonra enrich_spread_features ile doldurulacak
-
-    df = _compute_forward_target(df)
+    df = _compute_forward_targets(df)
     return df
 
 
-def enrich_spread_features(featured_df: pd.DataFrame, prices_df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Anlık alış-satış spread'i feature olarak ekle.
-    prices_df'te kalite ayrımı varsa ona göre merge.
-    """
-    if featured_df.empty or prices_df.empty:
-        featured_df["spread_pct"] = 0.0
-        featured_df["buy_sell_ratio"] = 1.0
-        return featured_df
-
-    prices = prices_df.copy()
-    if "quality" not in prices.columns:
-        prices["quality"] = 1
-    prices["quality"] = pd.to_numeric(prices["quality"], errors="coerce").fillna(1).astype(int)
-
-    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["spread_pct"] = np.where(
-        prices["buy_price_max"] > 0,
-        (prices["sell_price_min"] - prices["buy_price_max"]) / prices["buy_price_max"],
-        np.nan
-    )
-    prices["buy_sell_ratio"] = np.where(
-        prices["sell_price_min"] > 0,
-        prices["buy_price_max"] / prices["sell_price_min"],
-        np.nan
-    )
-
-    price_features = prices[["item_id", "city", "quality", "spread_pct", "buy_sell_ratio"]].drop_duplicates(
-        subset=["item_id", "city", "quality"]
-    )
-
-    result = featured_df.merge(price_features, on=["item_id", "city", "quality"], how="left")
-    result["spread_pct"] = result["spread_pct"].fillna(0.0)
-    result["buy_sell_ratio"] = result["buy_sell_ratio"].fillna(1.0)
-    return result
-
-
-def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
+def _compute_forward_targets(df: pd.DataFrame) -> pd.DataFrame:
     if df.empty or "log_price" not in df.columns:
         df["target_log_return_24h"] = np.nan
-        df["target_class"] = np.nan
+        df["target_class_24h"] = np.nan
+        df["target_log_return_90d"] = np.nan
+        df["target_class_90d"] = np.nan
         return df
 
     df["target_log_return_24h"] = np.nan
+    df["target_log_return_90d"] = np.nan
+
     group_cols = ["item_id", "city", "quality"]
 
     for keys, g in df.groupby(group_cols):
@@ -430,153 +429,220 @@ def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
             "log_price_future": g["log_price"].values,
         }).sort_values("timestamp")
 
-        left["target_timestamp"] = left["timestamp"] + pd.Timedelta(hours=24)
+        # 24 saat
+        left["target_t_24h"] = left["timestamp"] + pd.Timedelta(hours=24)
+        m24 = pd.merge_asof(
+            left.sort_values("target_t_24h"),
+            right.sort_values("timestamp"),
+            left_on="target_t_24h",
+            right_on="timestamp",
+            direction="nearest",
+            tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_24H),
+            suffixes=("", "_f"),
+        )
+        df.loc[m24["idx"].values, "target_log_return_24h"] = (
+            m24["log_price_future"].values - m24["log_price_now"].values
+        )
 
-        merged = pd.merge_asof(
-            left.sort_values("target_timestamp"),
+        # 90 gün
+        left["target_t_90d"] = left["timestamp"] + pd.Timedelta(days=HORIZON_DAYS_90D)
+        m90 = pd.merge_asof(
+            left.sort_values("target_t_90d"),
             right.sort_values("timestamp"),
-            left_on="target_timestamp",
+            left_on="target_t_90d",
             right_on="timestamp",
             direction="nearest",
-            tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS),
-            suffixes=("", "_future"),
+            tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_90D),
+            suffixes=("", "_f"),
         )
+        df.loc[m90["idx"].values, "target_log_return_90d"] = (
+            m90["log_price_future"].values - m90["log_price_now"].values
+        )
+
+    t24 = df["target_log_return_24h"]
+    df["target_class_24h"] = np.where(t24 < CLASS_DOWN_24H, 0, np.where(t24 > CLASS_UP_24H, 2, 1))
+    df.loc[t24.isna(), "target_class_24h"] = np.nan
 
-        target_log = merged["log_price_future"].values - merged["log_price_now"].values
-        df.loc[merged["idx"].values, "target_log_return_24h"] = target_log
+    t90 = df["target_log_return_90d"]
+    df["target_class_90d"] = np.where(t90 < CLASS_DOWN_90D, 0, np.where(t90 > CLASS_UP_90D, 2, 1))
+    df.loc[t90.isna(), "target_class_90d"] = np.nan
 
-    t = df["target_log_return_24h"]
-    df["target_class"] = np.where(t < CLASS_DOWN, 0, np.where(t > CLASS_UP, 2, 1))
-    df.loc[t.isna(), "target_class"] = np.nan
     return df
 
 
+def enrich_spread_features(featured_df: pd.DataFrame, prices_df: pd.DataFrame) -> pd.DataFrame:
+    if featured_df.empty or prices_df.empty:
+        featured_df["spread_pct"] = 0.0
+        featured_df["buy_sell_ratio"] = 1.0
+        return featured_df
+
+    prices = prices_df.copy()
+    if "quality" not in prices.columns:
+        prices["quality"] = 1
+    prices["quality"] = pd.to_numeric(prices["quality"], errors="coerce").fillna(1).astype(int)
+    for c in ["sell_price_min", "buy_price_max"]:
+        prices[c] = pd.to_numeric(prices[c], errors="coerce").astype("float64")
+
+    prices["spread_pct"] = np.where(
+        prices["buy_price_max"] > 0,
+        (prices["sell_price_min"] - prices["buy_price_max"]) / prices["buy_price_max"], np.nan
+    )
+    prices["buy_sell_ratio"] = np.where(
+        prices["sell_price_min"] > 0,
+        prices["buy_price_max"] / prices["sell_price_min"], np.nan
+    )
+
+    pf = prices[["item_id", "city", "quality", "spread_pct", "buy_sell_ratio"]].drop_duplicates(
+        subset=["item_id", "city", "quality"]
+    )
+    out = featured_df.merge(pf, on=["item_id", "city", "quality"], how="left")
+    out["spread_pct"] = out["spread_pct"].fillna(0.0)
+    out["buy_sell_ratio"] = out["buy_sell_ratio"].fillna(1.0)
+    return out
+
+
 # ---------------------------------------------------------------------------
-# MODEL
+# MODEL EĞİTİMİ (24h + 90d)
 # ---------------------------------------------------------------------------
 
 
-def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series, pd.DataFrame]:
+def _prepare_model_df(featured_df: pd.DataFrame, horizon: str) -> Tuple[pd.DataFrame, pd.Series, pd.DataFrame]:
+    """horizon: '24h' veya '90d'"""
     if featured_df.empty:
         return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
 
+    target_col = f"target_class_{horizon}"
+    if target_col not in featured_df.columns:
+        return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
+
     df = featured_df.copy()
     df["item_code"] = df["item_id"].astype("category").cat.codes
     df["city_code"] = df["city"].astype("category").cat.codes
     if "qual_code" not in df.columns:
         df["qual_code"] = df.get("quality", 1)
 
-    df = df.dropna(subset=["target_class", "lag_24h_log"]).copy()
-    df["target_class"] = df["target_class"].astype(int)
+    df = df.dropna(subset=[target_col]).copy()
+    df[target_col] = df[target_col].astype(int)
 
-    # Uzun pencereli feature'ları doldur (kısa pencereden)
-    for col in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h"]:
-        if col in df.columns:
-            df[col] = df[col].fillna(0.0)
+    # Doldur
+    fill_cols = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
+    for c in fill_cols:
+        if c in df.columns:
+            df[c] = df[c].fillna(0.0)
 
-    df["lag_168h_log"] = df["lag_168h_log"].fillna(df["lag_24h_log"])
-    df["lag_336h_log"] = df["lag_336h_log"].fillna(df["lag_168h_log"]).fillna(df["lag_24h_log"])
+    for c in ["lag_24h_log", "lag_168h_log", "lag_336h_log", "lag_720h_log", "lag_1440h_log"]:
+        if c in df.columns:
+            df[c] = df[c].fillna(df["log_price"])
 
-    df["rsi_14"] = df["rsi_14"].fillna(50.0)
-    df["volatility_24h"] = df["volatility_24h"].fillna(0.0)
-    df["volume_ratio"] = df["volume_ratio"].fillna(1.0)
-    df["ma_24h_ratio"] = df["ma_24h_ratio"].fillna(0.0)
-    df["ma_168h_ratio"] = df["ma_168h_ratio"].fillna(df["ma_24h_ratio"]).fillna(0.0)
-    df["city_price_deviation"] = df["city_price_deviation"].fillna(0.0)
-    df["spread_pct"] = df.get("spread_pct", pd.Series(0.0, index=df.index)).fillna(0.0)
-    df["buy_sell_ratio"] = df.get("buy_sell_ratio", pd.Series(1.0, index=df.index)).fillna(1.0)
+    for c in ["rsi_14"]:
+        df[c] = df[c].fillna(50.0)
+    for c in ["volatility_24h", "volatility_168h", "volume_ratio", "ma_24h_ratio",
+              "ma_168h_ratio", "ma_720h_ratio", "trend_slope_30d", "city_price_deviation",
+              "spread_pct", "buy_sell_ratio"]:
+        if c in df.columns:
+            df[c] = df[c].fillna(0.0)
 
-    model_df = df.dropna(subset=FEATURE_COLS + ["target_class"]).copy()
+    feature_cols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_90D
+    feature_cols = [c for c in feature_cols if c in df.columns]
 
-    X = model_df[FEATURE_COLS].astype("float64")
-    y = model_df["target_class"]
-    meta = model_df[["item_id", "city", "quality", "timestamp", "avg_price", "target_log_return_24h"]].copy()
+    model_df = df.dropna(subset=feature_cols + [target_col]).copy()
+    if model_df.empty:
+        return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
+
+    X = model_df[feature_cols].astype("float64")
+    y = model_df[target_col]
+    meta = model_df[["item_id", "city", "quality", "timestamp", "avg_price"]].copy()
     return X, y, meta
 
 
-def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMClassifier]:
+def train_model(X: pd.DataFrame, y: pd.Series, horizon: str) -> Optional[lgb.LGBMClassifier]:
     if len(X) < MIN_TRAIN_SAMPLES:
         return None
-
-    class_counts = y.value_counts().to_dict()
-    print(f"[TANI] Sınıf: {class_counts}")
-    if len(class_counts) < 3 or min(class_counts.values()) < 10:
+    cc = y.value_counts().to_dict()
+    print(f"[{horizon}] sınıf: {cc}")
+    if len(cc) < 3 or min(cc.values()) < 10:
         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:]
+    split = int(len(X) * 0.8)
+    X_tr, X_val = X.iloc[:split], X.iloc[split:]
+    y_tr, y_val = y.iloc[:split], y.iloc[split:]
 
+    n_est = 300 if horizon == "24h" else 250
     model = lgb.LGBMClassifier(
         objective="multiclass", num_class=3, metric="multi_logloss",
         boosting_type="gbdt",
         num_leaves=15, max_depth=5, min_child_samples=50,
-        learning_rate=0.03, n_estimators=300,
+        learning_rate=0.03, n_estimators=n_est,
         feature_fraction=0.8, bagging_fraction=0.8, bagging_freq=5,
         reg_alpha=0.5, reg_lambda=1.0,
         verbose=-1, random_state=42, n_jobs=-1,
     )
-
     model.fit(
-        X_train, y_train,
+        X_tr, y_tr,
         eval_set=[(X_val, y_val)],
         callbacks=[lgb.early_stopping(30, verbose=False), lgb.log_evaluation(0)],
     )
-
-    val_preds = model.predict(X_val)
-    val_acc = accuracy_score(y_val, val_preds)
-    print(f"[TANI] val_accuracy={val_acc:.4f}")
+    acc = accuracy_score(y_val, model.predict(X_val))
+    print(f"[{horizon}] val_accuracy={acc:.4f}")
     return model
 
 
-def predict_24h_returns(model, latest_features: pd.DataFrame) -> pd.DataFrame:
+def predict(model, latest_features: pd.DataFrame, horizon: str) -> pd.DataFrame:
     if latest_features.empty or model is None:
         return pd.DataFrame()
 
-    missing = [c for c in FEATURE_COLS if c not in latest_features.columns]
-    if missing:
-        return pd.DataFrame()
+    df = latest_features.copy()
+    df["item_code"] = df["item_id"].astype("category").cat.codes
+    df["city_code"] = df["city"].astype("category").cat.codes
+    if "qual_code" not in df.columns:
+        df["qual_code"] = df.get("quality", 1)
 
-    X_pred = latest_features.copy()
-    for col in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h"]:
-        if col in X_pred.columns:
-            X_pred[col] = X_pred[col].fillna(0.0)
-    X_pred["lag_168h_log"] = X_pred["lag_168h_log"].fillna(X_pred["lag_24h_log"])
-    X_pred["lag_336h_log"] = X_pred["lag_336h_log"].fillna(X_pred["lag_168h_log"]).fillna(X_pred["lag_24h_log"])
-    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_ratio"] = X_pred["volume_ratio"].fillna(1.0)
-    X_pred["ma_24h_ratio"] = X_pred["ma_24h_ratio"].fillna(0.0)
-    X_pred["ma_168h_ratio"] = X_pred["ma_168h_ratio"].fillna(X_pred["ma_24h_ratio"]).fillna(0.0)
-    X_pred["city_price_deviation"] = X_pred["city_price_deviation"].fillna(0.0)
-    X_pred["spread_pct"] = X_pred.get("spread_pct", pd.Series(0.0, index=X_pred.index)).fillna(0.0)
-    X_pred["buy_sell_ratio"] = X_pred.get("buy_sell_ratio", pd.Series(1.0, index=X_pred.index)).fillna(1.0)
-
-    X_ready = X_pred[FEATURE_COLS].astype("float64").dropna()
+    fill_cols = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
+    for c in fill_cols:
+        if c in df.columns:
+            df[c] = df[c].fillna(0.0)
+    for c in ["lag_24h_log", "lag_168h_log", "lag_336h_log", "lag_720h_log", "lag_1440h_log"]:
+        if c in df.columns:
+            df[c] = df[c].fillna(df["log_price"])
+    for c in ["rsi_14"]:
+        df[c] = df[c].fillna(50.0)
+    for c in ["volatility_24h", "volatility_168h", "volume_ratio", "ma_24h_ratio",
+              "ma_168h_ratio", "ma_720h_ratio", "trend_slope_30d", "city_price_deviation",
+              "spread_pct", "buy_sell_ratio"]:
+        if c in df.columns:
+            df[c] = df[c].fillna(0.0)
+
+    feature_cols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_90D
+    feature_cols = [c for c in feature_cols if c in df.columns]
+    X_ready = df[feature_cols].astype("float64").dropna()
     if X_ready.empty:
         return pd.DataFrame()
 
     probs = model.predict_proba(X_ready)
     pred_class = np.argmax(probs, axis=1)
-    expected_log = probs[:, 0] * CLASS_DOWN + probs[:, 1] * 0.0 + probs[:, 2] * CLASS_UP
-    clipped_log = np.clip(expected_log, CLASS_DOWN, CLASS_UP)
-    pred_return_pct = (np.exp(clipped_log) - 1) * 100
-
-    keep_cols = ["item_id", "city", "quality", "avg_price", "item_count",
-                 "volatility_24h", "rsi_14", "volume_ratio", "price_pct_7d",
-                 "is_downtrend", "chg_6h", "chg_24h", "chg_168h",
-                 "spread_pct", "buy_sell_ratio"]
-    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["pred_class"] = pred_class
-    result["prob_down"] = probs[:, 0]
-    result["prob_flat"] = probs[:, 1]
-    result["prob_up"] = probs[:, 2]
-    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["confidence"] = probs.max(axis=1)
-    return result
+
+    if horizon == "24h":
+        exp_log = probs[:, 0] * CLASS_DOWN_24H + probs[:, 2] * CLASS_UP_24H
+        clipped = np.clip(exp_log, CLASS_DOWN_24H, CLASS_UP_24H)
+    else:
+        exp_log = probs[:, 0] * CLASS_DOWN_90D + probs[:, 2] * CLASS_UP_90D
+        clipped = np.clip(exp_log, CLASS_DOWN_90D, CLASS_UP_90D)
+
+    keep = ["item_id", "city", "quality", "avg_price", "item_count",
+            "volatility_24h", "rsi_14", "volume_ratio", "price_pct_7d",
+            "is_downtrend", "chg_6h", "chg_24h", "chg_168h",
+            "spread_pct", "buy_sell_ratio"]
+    keep = [c for c in keep if c in df.columns]
+    out = df.loc[X_ready.index, keep].copy()
+    out["pred_class"] = pred_class
+    out["prob_down"] = probs[:, 0]
+    out["prob_flat"] = probs[:, 1]
+    out["prob_up"] = probs[:, 2]
+    out["predicted_log_return"] = clipped
+    out["predicted_return_pct"] = (np.exp(clipped) - 1) * 100
+    out["predicted_price"] = out["avg_price"] * np.exp(clipped)
+    out["confidence"] = probs.max(axis=1)
+    return out
 
 
 # ---------------------------------------------------------------------------
@@ -586,34 +652,28 @@ def predict_24h_returns(model, latest_features: pd.DataFrame) -> pd.DataFrame:
 
 def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
     reasons, passed = [], 0
-
     rsi = row.get("rsi_14", 50)
     if pd.notna(rsi) and rsi < DIP_RSI_MAX:
         passed += 1
         reasons.append(f"RSI={rsi:.0f}")
-
     pct = row.get("price_pct_7d", 0.5)
     if pd.notna(pct) and pct < DIP_PERCENTILE_MAX:
         passed += 1
         reasons.append(f"7g%={pct*100:.0f}")
-
     vr = row.get("volume_ratio", 1.0)
     if pd.notna(vr) and vr >= DIP_MIN_VOLUME_RATIO:
         passed += 1
         reasons.append(f"H×{vr:.1f}")
-
-    pred_pct = row.get("predicted_return_pct", 0)
-    if pd.notna(pred_pct) and pred_pct >= DIP_MIN_PREDICTED_PCT:
+    pp = row.get("predicted_return_pct", 0)
+    if pd.notna(pp) and pp >= DIP_MIN_PREDICTED_PCT:
         passed += 1
-        reasons.append(f"M={pred_pct:+.1f}%")
-
-    spread_pct = row.get("spread_pct", np.nan)
-    if pd.notna(spread_pct) and abs(spread_pct) < DIP_MAX_SPREAD_PCT:
+        reasons.append(f"M={pp:+.1f}%")
+    sp = row.get("spread_pct", np.nan)
+    if pd.notna(sp) and abs(sp) < DIP_MAX_SPREAD_PCT:
         passed += 1
-        reasons.append(f"Sp={spread_pct*100:.1f}%")
-
-    is_down = row.get("is_downtrend", 0)
-    if not is_down or (pd.notna(pred_pct) and pred_pct > 2):
+        reasons.append(f"Sp={sp*100:.1f}%")
+    down = row.get("is_downtrend", 0)
+    if not down or (pd.notna(pp) and pp > 2):
         passed += 1
         reasons.append("Trend✓")
 
@@ -623,117 +683,13 @@ def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
         sig = "🟡 ZAYIF AL"
     elif passed == 3 and pd.notna(rsi) and rsi < 45:
         sig = "🔵 İZLE"
-    elif is_down and pd.notna(pred_pct) and pred_pct < -2:
+    elif down and pd.notna(pp) and pp < -2:
         sig = "🔴 ALMA"
     else:
         sig = "⚪ BEKLE"
-
     return sig, " · ".join(reasons) if reasons else "—"
 
 
-# ---------------------------------------------------------------------------
-# BACKTEST
-# ---------------------------------------------------------------------------
-
-
-def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> 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) < 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": "Test boyutu çok küçük."}
-
-    results, all_predictions = [], []
-
-    for i in range(n_splits):
-        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 - 24
-        if train_end_idx <= 0:
-            continue
-
-        train_times = unique_times[:train_end_idx]
-        test_times = unique_times[test_start_idx:test_end_idx]
-
-        train_df = df[df["timestamp"].isin(train_times)]
-        test_df = df[df["timestamp"].isin(test_times)]
-
-        if len(train_df) < 50 or len(test_df) < 5:
-            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) < 30 or len(X_test) < 3 or y_train.nunique() < 3:
-            continue
-
-        model = lgb.LGBMClassifier(
-            objective="multiclass", num_class=3,
-            num_leaves=15, max_depth=5, min_child_samples=50,
-            learning_rate=0.03, n_estimators=200,
-            reg_alpha=0.5, reg_lambda=1.0,
-            verbose=-1, random_state=42, n_jobs=-1,
-        )
-        model.fit(X_train, y_train)
-
-        preds_class = model.predict(X_test)
-        probs = model.predict_proba(X_test)
-
-        accuracy = accuracy_score(y_test, preds_class)
-
-        y_dir = np.where(y_test == 2, 1, np.where(y_test == 0, 0, -1))
-        p_dir = np.where(preds_class == 2, 1, np.where(preds_class == 0, 0, -1))
-        mask = (y_dir >= 0) & (p_dir >= 0)
-        direction_acc = float(np.mean(y_dir[mask] == p_dir[mask])) if mask.sum() > 0 else 0.5
-
-        baseline_acc = float((y_test == 1).mean())
-
-        results.append({
-            "split": i + 1,
-            "train_samples": int(len(X_train)),
-            "test_samples": int(len(X_test)),
-            "accuracy": round(float(accuracy), 4),
-            "direction_accuracy": round(float(direction_acc), 4),
-            "baseline_accuracy": round(float(baseline_acc), 4),
-            "accuracy_lift_pct": round(float((accuracy - baseline_acc) * 100), 2),
-        })
-
-        test_meta = meta_test.copy()
-        test_meta["predicted_class"] = preds_class
-        test_meta["prob_up"] = probs[:, 2]
-        all_predictions.append(test_meta)
-
-    if not results:
-        return {"error": "Backtest tamamlanamadı."}
-
-    simulation = {"total_trades": 0, "win_rate_pct": 0.0, "avg_net_return_pct": 0.0,
-                  "profitable_trades": 0, "avg_confidence_pct": 0.0}
-    if all_predictions:
-        sim_df = pd.concat(all_predictions).dropna(subset=["target_log_return_24h"])
-        # Sadece YUKARI tahmini + yüksek güven
-        buys = sim_df[(sim_df["predicted_class"] == 2) & (sim_df["prob_up"] > 0.6)].copy()
-        if len(buys) > 0:
-            buys["net_return"] = buys["target_log_return_24h"] - TOTAL_TRADE_COST
-            simulation = {
-                "total_trades": int(len(buys)),
-                "win_rate_pct": round(float((buys["net_return"] > 0).mean() * 100), 2),
-                "avg_net_return_pct": round(float(buys["net_return"].mean() * 100), 4),
-                "profitable_trades": int((buys["net_return"] > 0).sum()),
-                "avg_confidence_pct": round(float(buys["prob_up"].mean() * 100), 1),
-            }
-
-    return {"results": results, "simulation": simulation, "n_splits_completed": len(results)}
-
-
 # ---------------------------------------------------------------------------
 # PIPELINE
 # ---------------------------------------------------------------------------
@@ -744,16 +700,20 @@ class DataPipeline:
         self.history_df = pd.DataFrame()
         self.prices_df = pd.DataFrame()
         self.featured_df = pd.DataFrame()
-        self.model = None
+        self.model_24h = None
+        self.model_90d = None
         self.last_update = None
         self.status_message = "Veri yüklenmedi."
-        self._backtest_cache = None
         self._diagnostics = {}
 
-        if _HAS_JOBLIB and os.path.exists(MODEL_PATH):
+        if _HAS_JOBLIB:
             try:
-                self.model = joblib.load(MODEL_PATH)
-                self.status_message = "Kayıtlı model yüklendi."
+                if os.path.exists(MODEL_PATH_24H):
+                    self.model_24h = joblib.load(MODEL_PATH_24H)
+                if os.path.exists(MODEL_PATH_90D):
+                    self.model_90d = joblib.load(MODEL_PATH_90D)
+                if self.model_24h or self.model_90d:
+                    self.status_message = "Kayıtlı model(ler) yüklendi."
             except Exception:
                 pass
 
@@ -761,7 +721,7 @@ class DataPipeline:
         item_ids = item_ids or ITEM_IDS
         cities = cities or CITIES
 
-        self.status_message = "Public API'den veri çekiliyor (5 kalite)..."
+        self.status_message = "Public API'den veri çekiliyor (3 kalite)..."
         ok, msg = check_api_health()
         if not ok:
             self.status_message = f"API erişilemiyor: {msg}"
@@ -780,15 +740,14 @@ class DataPipeline:
 
         self.history_df = clean_market_data(hist)
         self.prices_df = prices
-        n_qualities = self.history_df["quality"].nunique() if "quality" in self.history_df.columns else 1
-        self.status_message = f"✓ {len(self.history_df)} satır tarihsel ({n_qualities} kalite), {len(self.prices_df)} anlık."
+        n_q = self.history_df["quality"].nunique() if "quality" in self.history_df.columns else 1
+        self.status_message = f"✓ {len(self.history_df)} satır ({n_q} kalite), {len(self.prices_df)} anlık."
 
         save_to_csv(self.history_df, "history")
         save_to_csv(self.prices_df, "prices")
 
         self.featured_df = build_features(self.history_df)
         self.featured_df = enrich_spread_features(self.featured_df, self.prices_df)
-        self._backtest_cache = None
         self._update_diagnostics()
 
     def _update_diagnostics(self):
@@ -796,94 +755,95 @@ class DataPipeline:
         if df.empty:
             self._diagnostics = {}
             return
-        n_with_target = int(df["target_class"].notna().sum()) if "target_class" in df.columns else 0
-        class_dist = df["target_class"].value_counts().to_dict() if n_with_target > 0 else {}
+        n24 = int(df["target_class_24h"].notna().sum()) if "target_class_24h" in df.columns else 0
+        n90 = int(df["target_class_90d"].notna().sum()) if "target_class_90d" in df.columns else 0
+        cd24 = df["target_class_24h"].value_counts().to_dict() if n24 > 0 else {}
+        cd90 = df["target_class_90d"].value_counts().to_dict() if n90 > 0 else {}
         self._diagnostics = {
             "n_total": len(df),
-            "n_with_target": n_with_target,
-            "class_dist": class_dist,
-            "n_qualities": int(df["quality"].nunique()) if "quality" in df.columns else 1,
+            "n_24h": n24,
+            "n_90d": n90,
+            "class_24h": cd24,
+            "class_90d": cd90,
         }
-        print(f"[TANI] total={len(df)}, hedefli={n_with_target}, sınıf={class_dist}")
+        print(f"[TANI] total={len(df)}, 24h={n24}, 90d={n90}")
 
-    def train_model(self):
+    def train_all(self):
         if self.featured_df.empty:
             self.status_message = "Önce veri çekin."
             return False
 
-        diag = self._diagnostics or {}
-        if diag.get("n_with_target", 0) < MIN_TRAIN_SAMPLES:
-            self.status_message = f"Yetersiz örnek: {diag.get('n_with_target', 0)}"
-            return False
-
-        class_dist = diag.get("class_dist", {})
-        if len(class_dist) < 3 or min(class_dist.values()) < 10:
-            self.status_message = f"Sınıf dengesiz: {class_dist}"
-            return False
-
-        X, y, _ = prepare_model_data(self.featured_df)
-        if len(X) < MIN_TRAIN_SAMPLES:
-            self.status_message = f"Model için yetersiz: {len(X)}"
-            return False
-
-        self.model = train_global_model(X, y)
-        if self.model is None:
-            self.status_message = "Model eğitimi başarısız."
-            return False
-
-        self.status_message = f"✓ Model eğitildi ({len(X)} örnek)."
+        # 24h
+        X24, y24, _ = _prepare_model_df(self.featured_df, "24h")
+        if len(X24) >= MIN_TRAIN_SAMPLES:
+            self.model_24h = train_model(X24, y24, "24h")
+            if _HAS_JOBLIB and self.model_24h:
+                try:
+                    joblib.dump(self.model_24h, MODEL_PATH_24H)
+                except Exception:
+                    pass
+
+        # 90d
+        X90, y90, _ = _prepare_model_df(self.featured_df, "90d")
+        n90 = len(X90)
+        if n90 >= MIN_TRAIN_SAMPLES:
+            self.model_90d = train_model(X90, y90, "90d")
+            if _HAS_JOBLIB and self.model_90d:
+                try:
+                    joblib.dump(self.model_90d, MODEL_PATH_90D)
+                except Exception:
+                    pass
 
-        if _HAS_JOBLIB:
-            try:
-                joblib.dump(self.model, MODEL_PATH)
-            except Exception:
-                pass
+        msgs = []
+        if self.model_24h:
+            msgs.append("24h✓")
+        else:
+            msgs.append("24h✗")
+        if self.model_90d:
+            msgs.append(f"90d✓ ({n90} örnek)")
+        else:
+            msgs.append(f"90d✗ (yetersiz: {n90})")
 
+        self.status_message = "Model: " + " · ".join(msgs)
         self.last_update = dt.datetime.now()
-        return True
+        return self.model_24h is not None or self.model_90d is not None
 
-    def get_latest_predictions(self) -> pd.DataFrame:
-        if self.featured_df.empty or self.model is None:
+    def get_latest(self) -> pd.DataFrame:
+        if self.featured_df.empty:
             return pd.DataFrame()
-
-        latest = self.featured_df.sort_values("timestamp").groupby(
+        return self.featured_df.sort_values("timestamp").groupby(
             ["item_id", "city", "quality"]
         ).tail(1).copy()
 
-        latest["item_code"] = latest["item_id"].astype("category").cat.codes
-        latest["city_code"] = latest["city"].astype("category").cat.codes
-        if "qual_code" not in latest.columns:
-            latest["qual_code"] = latest.get("quality", 1)
-
-        for col in FEATURE_COLS:
-            if col not in latest.columns:
-                latest[col] = 0.0
-
-        preds = predict_24h_returns(self.model, latest)
+    def predict_24h(self) -> pd.DataFrame:
+        latest = self.get_latest()
+        if latest.empty or self.model_24h is None:
+            return pd.DataFrame()
+        preds = predict(self.model_24h, latest, "24h")
         if preds.empty:
             return preds
 
         if not self.prices_df.empty:
-            price_info = self.prices_df[["item_id", "city", "quality",
-                                          "sell_price_min", "buy_price_max"]].copy()
-            for col in ["sell_price_min", "buy_price_max"]:
-                price_info[col] = pd.to_numeric(price_info[col], errors="coerce").astype("float64")
-            preds = preds.merge(price_info, on=["item_id", "city", "quality"], how="left")
+            pi = self.prices_df[["item_id", "city", "quality",
+                                  "sell_price_min", "buy_price_max"]].copy()
+            for c in ["sell_price_min", "buy_price_max"]:
+                pi[c] = pd.to_numeric(pi[c], errors="coerce").astype("float64")
+            preds = preds.merge(pi, on=["item_id", "city", "quality"], how="left")
             preds["spread"] = preds["sell_price_min"] - preds["buy_price_max"]
         else:
             preds["spread"] = np.nan
 
         preds["net_return_pct"] = preds["predicted_return_pct"] - (TOTAL_TRADE_COST * 100)
-
-        dip_signals = preds.apply(compute_dip_signal, axis=1, result_type="expand")
-        preds["Dip Sinyali"] = dip_signals[0]
-        preds["Sinyal Detayı"] = dip_signals[1]
+        dip = preds.apply(compute_dip_signal, axis=1, result_type="expand")
+        preds["Dip Sinyali"] = dip[0]
+        preds["Sinyal Detayı"] = dip[1]
         return preds
 
-    def get_backtest(self):
-        if self._backtest_cache is None:
-            self._backtest_cache = walk_forward_backtest(self.featured_df)
-        return self._backtest_cache
+    def predict_90d(self) -> pd.DataFrame:
+        latest = self.get_latest()
+        if latest.empty or self.model_90d is None:
+            return pd.DataFrame()
+        return predict(self.model_90d, latest, "90d")
 
 
 pipeline = DataPipeline()
@@ -897,43 +857,81 @@ pipeline = DataPipeline()
 def get_dashboard_metrics():
     diag = pipeline._diagnostics
     if pipeline.featured_df.empty:
-        return pd.DataFrame({
-            "Metrik": ["Durum", "Veri Kaynağı", "Model"],
-            "Değer": ["Veri yok.", "Public AODP API", "Yok" if pipeline.model is None else "Yüklü"],
-        })
+        return pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Veri yok."]})
 
     df = pipeline.featured_df
-    cd = diag.get("class_dist", {})
-    metrics = {
-        "Veri Kaynağı": "Public AODP API (europe)",
-        "Görev": "3-sınıf sınıflandırma",
-        "Kalite Sayısı": diag.get("n_qualities", 1),
+    m = {
+        "Veri Kaynağı": "Public AODP API",
         "Toplam Gözlem": len(df),
-        "Hedefli Satır": diag.get("n_with_target", 0),
-        "Sınıf AŞAĞI": cd.get(0, 0),
-        "Sınıf SABİT": cd.get(1, 0),
-        "Sınıf YUKARI": cd.get(2, 0),
+        "Hedefli 24h": diag.get("n_24h", 0),
+        "Hedefli 90d": diag.get("n_90d", 0),
+        "Sınıf 24h (A/S/Y)": str(diag.get("class_24h", {})),
+        "Sınıf 90d (A/S/Y)": str(diag.get("class_90d", {})),
+        "Model 24h": "Eğitildi" if pipeline.model_24h else "Yok",
+        "Model 90d": "Eğitildi" if pipeline.model_90d else "Yok",
         "Tarih Aralığı": f"{df['timestamp'].min().date()} - {df['timestamp'].max().date()}",
-        "Model": "Eğitildi" if pipeline.model else "Eğitilmedi",
         "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"])
+    return pd.DataFrame(list(m.items()), columns=["Metrik", "Değer"])
+
+
+def get_prediction_24h_table():
+    preds = pipeline.predict_24h()
+    if preds.empty:
+        return pd.DataFrame({"Bilgi": ["24h tahmini yok."]})
+
+    preds = preds.copy()
+    preds["Ürün"] = preds["item_id"].apply(item_display_name)
+    preds["Kalite"] = preds["quality"].apply(quality_name)
+    preds["Şehir"] = preds["city"]
+    preds["Mevcut"] = preds["avg_price"].round(0)
+    preds["24s Tahmin"] = preds["predicted_price"].round(0)
+    preds["Değişim %"] = preds["predicted_return_pct"].round(2)
+    preds["Sınıf"] = preds["pred_class"].map({0: "↓", 1: "→", 2: "↑"})
+    preds["P(↑)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
+    preds["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
+    preds["Net %"] = preds["net_return_pct"].round(2)
+
+    cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "24s Tahmin",
+            "Değişim %", "Sınıf", "P(↑)", "Güven", "Net %", "Dip Sinyali"]
+    return preds[cols].sort_values("Güven", ascending=False)
+
+
+def get_prediction_90d_table():
+    preds = pipeline.predict_90d()
+    if preds.empty:
+        return pd.DataFrame({"Bilgi": [
+            "3 aylık tahmin için yeterli veri yok. "
+            "En az 6 ay geçmiş veri gerekir. API'den daha fazla ürün/şehir ekleyin."
+        ]})
+
+    preds = preds.copy()
+    preds["Ürün"] = preds["item_id"].apply(item_display_name)
+    preds["Kalite"] = preds["quality"].apply(quality_name)
+    preds["Şehir"] = preds["city"]
+    preds["Mevcut"] = preds["avg_price"].round(0)
+    preds["3 Ay Tahmini"] = preds["predicted_price"].round(0)
+    preds["Değişim %"] = preds["predicted_return_pct"].round(2)
+    preds["Trend"] = preds["pred_class"].map({0: "↓ AŞAĞI", 1: "→ SABİT", 2: "↑ YUKARI"})
+    preds["P(↑)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
+    preds["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
+
+    cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "3 Ay Tahmini",
+            "Değişim %", "Trend", "P(↑)", "Güven"]
+    return preds[cols].sort_values("Güven", ascending=False)
 
 
 def get_analysis_table():
     if pipeline.featured_df.empty:
         return pd.DataFrame()
 
-    latest = pipeline.featured_df.sort_values("timestamp").groupby(
-        ["item_id", "city", "quality"]
-    ).tail(1).copy()
-
+    latest = pipeline.get_latest()
     if not pipeline.prices_df.empty:
-        price_info = pipeline.prices_df[["item_id", "city", "quality",
-                                          "sell_price_min", "buy_price_max"]].copy()
-        for col in ["sell_price_min", "buy_price_max"]:
-            price_info[col] = pd.to_numeric(price_info[col], errors="coerce").astype("float64")
-        latest = latest.merge(price_info, on=["item_id", "city", "quality"], how="left")
+        pi = pipeline.prices_df[["item_id", "city", "quality",
+                                  "sell_price_min", "buy_price_max"]].copy()
+        for c in ["sell_price_min", "buy_price_max"]:
+            pi[c] = pd.to_numeric(pi[c], errors="coerce").astype("float64")
+        latest = latest.merge(pi, on=["item_id", "city", "quality"], how="left")
     else:
         latest["sell_price_min"] = np.nan
         latest["buy_price_max"] = np.nan
@@ -941,65 +939,40 @@ def get_analysis_table():
     latest["Ürün"] = latest["item_id"].apply(item_display_name)
     latest["Kalite"] = latest["quality"].apply(quality_name)
     latest["Şehir"] = latest["city"]
-    latest["Mevcut Fiyat"] = latest["avg_price"].round(0)
+    latest["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%"] = (latest["price_pct_7d"] * 100).round(0)
-    latest["Trend"] = np.where(latest["is_downtrend"] == 1, "↓", "→")
-    latest["Likidite"] = pd.cut(latest["item_count"], bins=[-1, 10, 50, 200, np.inf],
-                                 labels=["Düşük", "Orta", "İyi", "Yüksek"]).astype(str)
+    latest["30g Trend"] = latest["trend_slope_30d"].round(4)
 
-    cols = ["Ürün", "Kalite", "Şehir", "Mevcut Fiyat", "Hacim", "Spread",
-            "RSI", "7g%", "Trend", "Likidite"]
+    cols = ["Ürün", "Kalite", "Şehir", "Fiyat", "Hacim", "Spread",
+            "RSI", "7g%", "30g Trend"]
     return latest[cols].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."]})
-
-    preds = preds.copy()
-    preds["Ürün"] = preds["item_id"].apply(item_display_name)
-    preds["Kalite"] = preds["quality"].apply(quality_name)
-    preds["Şehir"] = preds["city"]
-    preds["Mevcut Fiyat"] = preds["avg_price"].round(0)
-    preds["Tahmin"] = preds["pred_class"].map({0: "AŞAĞI", 1: "SABİT", 2: "YUKARI"})
-    preds["P(↑)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["Güvenilirlik"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["Tahmini Değişim %"] = preds["predicted_return_pct"].round(2)
-    preds["Net Getiri %"] = preds["net_return_pct"].round(2)
-
-    cols = ["Ürün", "Kalite", "Şehir", "Mevcut Fiyat", "Tahmin",
-            "P(↑)", "Güvenilirlik", "Tahmini Değişim %", "Net Getiri %", "Dip Sinyali"]
-    return preds[cols].sort_values("Güvenilirlik", ascending=False)
-
-
-def get_dip_alim_table():
-    preds = pipeline.get_latest_predictions()
+def get_dip_table():
+    preds = pipeline.predict_24h()
     if preds.empty:
         return pd.DataFrame({"Bilgi": ["Tahmin yok."]})
-
     dip = preds[preds["Dip Sinyali"].isin(["🟢 GÜÇLÜ AL", "🟡 ZAYIF AL", "🔵 İZLE"])].copy()
     if dip.empty:
-        return pd.DataFrame({"Bilgi": ["Şu anda dip alım sinyali yok."]})
+        return pd.DataFrame({"Bilgi": ["Dip sinyali yok."]})
 
     order = {"🟢 GÜÇLÜ AL": 0, "🟡 ZAYIF AL": 1, "🔵 İZLE": 2}
     dip["_r"] = dip["Dip Sinyali"].map(order)
-
     dip["Ürün"] = dip["item_id"].apply(item_display_name)
     dip["Kalite"] = dip["quality"].apply(quality_name)
     dip["Şehir"] = dip["city"]
-    dip["Mevcut Fiyat"] = dip["avg_price"].round(0)
+    dip["Mevcut"] = dip["avg_price"].round(0)
     dip["RSI"] = dip["rsi_14"].round(0)
     dip["7g%"] = (dip["price_pct_7d"] * 100).round(0)
     dip["P(↑)"] = (dip["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-    dip["Net Getiri %"] = dip["net_return_pct"].round(2)
-
+    dip["Net %"] = dip["net_return_pct"].round(2)
     dip = dip.sort_values(["_r", "confidence"], ascending=[True, False])
-    cols = ["Dip Sinyali", "Ürün", "Kalite", "Şehir", "Mevcut Fiyat",
-            "RSI", "7g%", "P(↑)", "Net Getiri %", "Sinyal Detayı"]
+
+    cols = ["Dip Sinyali", "Ürün", "Kalite", "Şehir", "Mevcut",
+            "RSI", "7g%", "P(↑)", "Net %", "Sinyal Detayı"]
     return dip[cols].head(50)
 
 
@@ -1013,12 +986,10 @@ def get_arbitrage_table():
     prices["quality"] = pd.to_numeric(prices["quality"], errors="coerce").fillna(1).astype(int)
     for c in ["sell_price_min", "buy_price_max"]:
         prices[c] = pd.to_numeric(prices[c], errors="coerce").astype("float64")
-
     prices = prices[prices["sell_price_min"] > 0]
     if prices.empty:
-        return pd.DataFrame({"Bilgi": ["Geçerli fiyat yok."]})
+        return pd.DataFrame({"Bilgi": ["Fiyat yok."]})
 
-    # Kalite bazlı arbitraj — T4.0 ile T4.2 karıştırılmıyor
     buy = prices.loc[prices.groupby(["item_id", "quality"])["sell_price_min"].idxmin()][
         ["item_id", "quality", "city", "sell_price_min"]
     ].rename(columns={"city": "buy_city", "sell_price_min": "buy_price"})
@@ -1034,108 +1005,86 @@ def get_arbitrage_table():
 
     arb["brüt"] = arb["sell_price"] - arb["buy_price"]
     arb["maliyet"] = arb["buy_price"] * SETUP_FEE_RATE + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
-    arb["net_kâr"] = arb["brüt"] - arb["maliyet"]
-    arb["marj_%"] = (arb["net_kâr"] / arb["buy_price"]) * 100
-    arb = arb[arb["net_kâr"] > 0].sort_values("marj_%", ascending=False)
+    arb["net"] = arb["brüt"] - arb["maliyet"]
+    arb["marj"] = (arb["net"] / arb["buy_price"]) * 100
+    arb = arb[arb["net"] > 0].sort_values("marj", ascending=False)
 
     if arb.empty:
         return pd.DataFrame({"Bilgi": ["Kârlı arbitraj yok."]})
 
     arb["Ürün"] = arb["item_id"].apply(item_display_name)
     arb["Kalite"] = arb["quality"].apply(quality_name)
-    arb["Alış Şehri"] = arb["buy_city"]
-    arb["Satış Şehri"] = arb["sell_city"]
-    arb["Alış"] = arb["buy_price"].round(0)
-    arb["Satış"] = arb["sell_price"].round(0)
-    arb["Net Kâr"] = arb["net_kâr"].round(0)
-    arb["Marj %"] = arb["marj_%"].round(1)
-
-    cols = ["Ürün", "Kalite", "Alış Şehri", "Satış Şehri", "Alış", "Satış", "Net Kâr", "Marj %"]
+    arb["Alış"] = arb["buy_city"]
+    arb["Satış"] = arb["sell_city"]
+    arb["Alış Fiyatı"] = arb["buy_price"].round(0)
+    arb["Satış Fiyatı"] = arb["sell_price"].round(0)
+    arb["Net Kâr"] = arb["net"].round(0)
+    arb["Marj %"] = arb["marj"].round(1)
+
+    cols = ["Ürün", "Kalite", "Alış", "Satış", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Marj %"]
     return arb[cols].head(50)
 
 
-def get_model_performance_plot():
-    if pipeline.model is None:
-        return go.Figure().update_layout(title="Model eğitilmedi", template="plotly_dark")
+def get_importance_plot(horizon: str = "24h"):
+    model = pipeline.model_24h if horizon == "24h" else pipeline.model_90d
+    if model is None:
+        return go.Figure().update_layout(title=f"{horizon} model yok", template="plotly_dark")
     try:
-        df_imp = pd.DataFrame({
-            "Özellik": pipeline.model.feature_name_,
-            "Önem": pipeline.model.feature_importances_,
+        df = pd.DataFrame({
+            "Özellik": model.feature_name_,
+            "Önem": model.feature_importances_,
         }).sort_values("Önem", ascending=True).tail(20)
-        fig = px.bar(df_imp, x="Önem", y="Özellik", orientation="h",
-                     title="Feature Importance", template="plotly_dark")
+        fig = px.bar(df, x="Önem", y="Özellik", orientation="h",
+                     title=f"{horizon} Feature Importance", template="plotly_dark")
         fig.update_layout(height=600)
         return fig
     except Exception as e:
         return go.Figure().update_layout(title=f"Hata: {e}", template="plotly_dark")
 
 
-def get_backtest_outputs():
-    bt = pipeline.get_backtest()
-    if "error" in bt:
-        return (pd.DataFrame({"Bilgi": [bt["error"]]}),
-                go.Figure().update_layout(title="Hata", template="plotly_dark"),
-                pd.DataFrame())
-
-    rdf = pd.DataFrame(bt["results"])
-    fig = go.Figure()
-    fig.add_trace(go.Bar(name="Model Acc", x=rdf["split"], y=rdf["accuracy"], marker_color="cyan"))
-    fig.add_trace(go.Bar(name="Baseline", x=rdf["split"], y=rdf["baseline_accuracy"], marker_color="gray"))
-    fig.update_layout(title="Accuracy vs Baseline", xaxis_title="Split",
-                      yaxis_title="Accuracy", barmode="group", template="plotly_dark")
-
-    sim = pd.DataFrame([bt["simulation"]]) if bt.get("simulation") else pd.DataFrame()
-    return rdf, fig, sim
-
-
 def list_csv_files() -> pd.DataFrame:
     rows = []
     if os.path.isdir(DATA_DIR):
-        for fname in sorted(os.listdir(DATA_DIR)):
-            if fname.endswith(".csv"):
-                fpath = os.path.join(DATA_DIR, fname)
+        for f in sorted(os.listdir(DATA_DIR)):
+            if f.endswith(".csv"):
+                fp = os.path.join(DATA_DIR, f)
                 try:
                     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"),
+                        "Dosya": f,
+                        "Boyut (KB)": round(os.path.getsize(fp) / 1024, 2),
+                        "Son Değişiklik": dt.datetime.fromtimestamp(os.path.getmtime(fp)).strftime("%Y-%m-%d %H:%M:%S"),
                     })
                 except OSError:
                     continue
     return pd.DataFrame(rows) if rows else pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
 
 
-def refresh_data_ui():
+def refresh_all():
     try:
         pipeline.fetch_data()
         if not pipeline.featured_df.empty:
-            pipeline.train_model()
+            pipeline.train_all()
     except Exception as e:
         pipeline.status_message = f"Hata: {e}"
         import traceback
         traceback.print_exc()
 
-    try:
-        bt_table, bt_fig, sim_table = get_backtest_outputs()
-    except Exception:
-        bt_table, sim_table = pd.DataFrame(), pd.DataFrame()
-        bt_fig = go.Figure().update_layout(title="Hata", template="plotly_dark")
-
     def _safe(fn, default):
         try:
             return fn()
-        except Exception as e:
-            return pd.DataFrame({"Bilgi": [f"Hata: {e}"]}) if default is None else default
+        except Exception:
+            return default
 
     return (
         pipeline.status_message,
         _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_prediction_24h_table, pd.DataFrame()),
+        _safe(get_prediction_90d_table, pd.DataFrame()),
+        _safe(get_dip_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(get_importance_plot, go.Figure().update_layout(title="—", template="plotly_dark")),
+        _safe(lambda: get_importance_plot("90d"), go.Figure().update_layout(title="—", template="plotly_dark")),
         _safe(list_csv_files, pd.DataFrame()),
     )
 
@@ -1150,10 +1099,9 @@ 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(),
+        go.Figure().update_layout(title="Yenile", template="plotly_dark"),
         go.Figure().update_layout(title="Yenile", template="plotly_dark"),
-        pd.DataFrame(),
-        go.Figure().update_layout(title="Veri gerekli", template="plotly_dark"),
-        pd.DataFrame(),
         _safe(list_csv_files, pd.DataFrame()),
     )
 
@@ -1167,85 +1115,85 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
 
     gr.Markdown(
         """
-        # 🦅 GOSHAWK ALBION MARKET AI — v2.0
-        **Kalite ayrımı + uzun vadeli trend + spread feature'ları** | Avrupa Sunucusu
-        *LightGBM 3-sınıf sınıflandırma: AŞAĞI / SABİT / YUKARI*
+        # 🦅 GOSHAWK ALBION MARKET AI v3.0
+        **Çok ufuklu tahmin:** 24 saat + 3 ay (90 gün) | Avrupa Sunucusu
 
-        **⚠️ Risk Uyarısı:** Yatırım tavsiyesi değildir.
+        **⚠️ Risk Uyarısı:** 3 aylık tahmin **düşük doğrulukludur** (patch/sezon değişimleri modeli bozar).
+        Kesin fiyat değil, **trend yönü** olarak kullanın.
         """
     )
 
     with gr.Row():
-        refresh_btn = gr.Button("🔄 Verileri Yenile ve Modeli Eğit", variant="primary", scale=1)
+        refresh_btn = gr.Button("🔄 Verileri Yenile ve Modelleri Eğit", variant="primary", scale=1)
         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", interactive=False, wrap=True)
             gr.Markdown(
-                "### v2.0 Yenilikleri\n"
-                "- **Kalite ayrımı:** T4.0, T4.1, T4.2 ayrı ürün olarak işlenir\n"
-                "- **7/14 günlük trend:** `lag_168h`, `lag_336h`, `chg_168h`, `chg_336h`\n"
-                "- **Spread feature:** Alış-satış farkı modele girdi\n"
-                "- **Arbitraj:** Kalite bazlı, T4.0 ile T4.2 karışmaz\n"
-                "- **7g yüzdelik konum:** Dip noktası daha net\n\n"
-                "### Sınıflar\n"
-                f"- AŞAĞI: log < {CLASS_DOWN:.2f}\n"
-                f"- SABİT: arada\n"
-                f"- YUKARI: log > {CLASS_UP:.2f}\n\n"
+                "### İki Model\n"
+                "**24h Model:** kısa vadeli sinyaller için, ±%3 sınırı, yüksek doğruluk\n"
+                "**90d Model:** uzun vadeli trend için, ±%10 sınırı, düşük doğruluk\n\n"
+                "### 3 Aylık Tahmin Sınırları\n"
+                "- En az **6 ay geçmiş veri** gerekir\n"
+                "- API'de çoğu ürün için 3-4 ay veri var → **sınırlı**\n"
+                "- Yeni patch/sezon çıkarsa **tamamen yanılır**\n"
+                "- **Trend yönü** için kullan, fiyat için değil\n\n"
                 "### Riskler\n"
-                "- Kalite/enchant hâlâ sınırlı\n"
-                "- Overfit kontrolü yapın"
+                "- 3 aylık tahmin = düşük güven\n"
+                "- Model bir önceki dönemi öğrenir, geleceği değil"
             )
 
-        with gr.TabItem("🎯 DİP ALIM"):
-            dip_alim_table = gr.Dataframe(label="Dip Alım Sinyalleri", interactive=False)
+        with gr.TabItem("🔮 24 Saat Tahmin"):
+            pred_24h_table = gr.Dataframe(label="24s Tahminler", interactive=False)
 
-        with gr.TabItem("🔮 Tahminler"):
-            prediction_table = gr.Dataframe(label="Tüm Tahminler", interactive=False)
+        with gr.TabItem("📅 3 Aylık Tahmin"):
+            pred_90d_table = gr.Dataframe(label="90 Gün Tahminler", interactive=False)
+            gr.Markdown(
+                "*3 aylık tahmin **trend göstergesidir**, kesin fiyat değil. "
+                "Yeni patch, sezon, meta değişimi modeli bozar. "
+                "**Güven %50'nin altındaysa işlem yapmayın.***"
+            )
+
+        with gr.TabItem("🎯 DİP ALIM"):
+            dip_table = gr.Dataframe(label="Dip Alım Sinyalleri (24h)", interactive=False)
 
-        with gr.TabItem("📦 100 Ürün"):
+        with gr.TabItem("📦 Ürün Analizi"):
             analysis_table = gr.Dataframe(label="Ürün Analizi", interactive=False)
 
         with gr.TabItem("🚚 Arbitraj"):
             arbitrage_table = gr.Dataframe(label="Arbitraj (Kalite Bazlı)", interactive=False)
-            gr.Markdown(
-                "*T4.0 Normal ile T4.2 Outstanding ayrı hesaplanır. "
-                "Thetford'daki ucuz T4.0 Cape, başka şehirde pahalıysa burada görünür.*"
-            )
 
-        with gr.TabItem("📈 Model"):
-            performance_plot = gr.Plot(label="Feature Importance")
+        with gr.TabItem("📈 24h Model"):
+            importance_24h = gr.Plot(label="24h Feature Importance")
 
-        with gr.TabItem("🧪 Backtest"):
-            backtest_table = gr.Dataframe(label="Split Sonuçları", interactive=False)
-            backtest_plot = gr.Plot(label="Accuracy vs Baseline")
-            simulation_table = gr.Dataframe(label="Simülasyon", interactive=False)
+        with gr.TabItem("📈 90d Model"):
+            importance_90d = gr.Plot(label="90d Feature Importance")
 
         with gr.TabItem("🗄️ Veri"):
             gr.Markdown(
                 "**API:** europe.albion-online-data.com\n"
-                "**Kaliteler:** 1-5 (Normal→Masterpiece)\n"
-                f"**Maliyet:** %{TOTAL_TRADE_COST*100:.1f}\n"
-                f"**Sınıf sınırı:** ±%{CLASS_UP*100:.0f}"
+                "**Kalite:** 1, 2, 3\n"
+                "**Time-scale:** 6h\n"
+                f"**24h sınırı:** ±%{CLASS_UP_24H*100:.0f}\n"
+                f"**90d sınırı:** ±%{CLASS_UP_90D*100:.0f}"
             )
-            csv_files = gr.Dataframe(label="CSV Dosyaları", interactive=False,
+            csv_files = gr.Dataframe(label="CSV", interactive=False,
                                      headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])
 
     refresh_btn.click(
-        fn=refresh_data_ui,
+        fn=refresh_all,
         inputs=[],
-        outputs=[status_text, dashboard_table, analysis_table, prediction_table,
-                 dip_alim_table, arbitrage_table, performance_plot, backtest_table,
-                 backtest_plot, simulation_table, csv_files],
+        outputs=[status_text, dashboard_table, analysis_table, pred_24h_table,
+                 pred_90d_table, dip_table, arbitrage_table, importance_24h,
+                 importance_90d, csv_files],
     )
 
     demo.load(
         fn=initial_load,
         inputs=[],
-        outputs=[dashboard_table, analysis_table, prediction_table, dip_alim_table,
-                 arbitrage_table, performance_plot, backtest_table, backtest_plot,
-                 simulation_table, csv_files],
+        outputs=[dashboard_table, analysis_table, pred_24h_table, pred_90d_table,
+                 dip_table, arbitrage_table, importance_24h, importance_90d, csv_files],
     )