Update app.py

app.py

@@ -1,6 +1,6 @@
 # app.py
-# GOSHAWK ALBION MARKET AI v3.0
-# 24h + 3 aylık (90 gün) çok ufuklu tahmin
+# GOSHAWK ALBION MARKET AI v3.1
+# 24h model + 90d hibrit (model varsa model, yoksa trend projeksiyonu)
 
 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, mean_absolute_error
+from sklearn.metrics import accuracy_score
 
 import gradio as gr
 
@@ -105,25 +105,28 @@ os.makedirs(DATA_DIR, exist_ok=True)
 MODEL_DIR = os.path.join(DATA_DIR, "models")
 os.makedirs(MODEL_DIR, exist_ok=True)
 MODEL_PATH_24H = os.path.join(MODEL_DIR, "gos_hawk_24h.pkl")
-MODEL_PATH_90D = os.path.join(MODEL_DIR, "gos_hawk_90d.pkl")
+MODEL_PATH_30D = os.path.join(MODEL_DIR, "gos_hawk_30d.pkl")
 
 MIN_TRAIN_SAMPLES = 150
 REQUEST_TIMEOUT = 60
 MAX_RETRIES = 3
 RETRY_BACKOFF = 2
 
-HISTORY_TIME_SCALE = 6  # 6h — 3 aylık veri için saatlik çok ağır
+HISTORY_TIME_SCALE = 6
 
-# 24h sınıflandırma
+# 24h model
 CLASS_DOWN_24H = -0.03
 CLASS_UP_24H = 0.03
 TARGET_TOLERANCE_HOURS_24H = 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
+# 30 GÜN model (3 ay yerine 30 gün — veri bulunabilirliği için)
+HORIZON_DAYS_30D = 30
+CLASS_DOWN_30D = -0.10
+CLASS_UP_30D = 0.10
+TARGET_TOLERANCE_HOURS_30D = 48
+
+# Trend projeksiyon (30d veri yoksa fallback)
+TREND_PROJECTION_DAYS = 90
 
 # Dip sinyali
 DIP_RSI_MAX = 40.0
@@ -132,7 +135,6 @@ DIP_MIN_VOLUME_RATIO = 1.0
 DIP_MIN_PREDICTED_PCT = -1.0
 DIP_MAX_SPREAD_PCT = 0.15
 
-# 24h feature'lar
 FEATURE_COLS_24H = [
     "hour", "dayofweek",
     "lag_24h_log", "lag_168h_log", "lag_336h_log",
@@ -145,15 +147,14 @@ FEATURE_COLS_24H = [
     "item_code", "city_code",
 ]
 
-# 90d feature'lar — daha uzun vadeli
-FEATURE_COLS_90D = [
+FEATURE_COLS_30D = [
     "month", "dayofweek",
-    "lag_720h_log", "lag_1440h_log",  # 30g, 60g
-    "chg_336h", "chg_720h", "chg_1440h",  # 14g, 30g, 60g değişim
+    "lag_168h_log", "lag_336h_log", "lag_720h_log",
+    "chg_168h", "chg_336h", "chg_720h",
     "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
+    "ma_168h_ratio", "ma_720h_ratio",
+    "trend_slope_30d",
     "city_price_deviation",
     "spread_pct", "buy_sell_ratio", "qual_code",
     "item_code", "city_code",
@@ -165,7 +166,7 @@ FEATURE_COLS_90D = [
 
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
-    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/3.0", "Accept": "application/json"}
+    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/3.1", "Accept": "application/json"}
     for attempt in range(MAX_RETRIES):
         try:
             resp = requests.get(url, params=params, headers=headers, timeout=REQUEST_TIMEOUT)
@@ -189,7 +190,6 @@ def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
 
 
 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]
@@ -213,7 +213,6 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
 
 def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 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]
@@ -295,7 +294,7 @@ def save_to_csv(df: pd.DataFrame, name: str) -> str:
 
 
 # ---------------------------------------------------------------------------
-# FEATURE ENGINEERING
+# FEATURES
 # ---------------------------------------------------------------------------
 
 
@@ -308,13 +307,11 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
 
 
 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)
+        return float(np.polyfit(x, y, 1)[0])
     except Exception:
         return 0.0
 
@@ -322,7 +319,6 @@ def _linear_trend_slope(y: np.ndarray) -> float:
 def build_features(df: pd.DataFrame) -> pd.DataFrame:
     if df.empty:
         return df
-
     if "quality" not in df.columns:
         df["quality"] = 1
 
@@ -339,12 +335,16 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     group_cols = ["item_id", "city", "quality"]
     df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
 
-    # Kısa vadeli (24h model)
+    # 24h lag'ler
     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)
 
-    for chg in [1, 6, 24, 168, 336]:
+    # 30d lag'ler
+    df["lag_720h_log"] = df.groupby(group_cols)["log_price"].shift(720)
+    df["lag_1440h_log"] = df.groupby(group_cols)["log_price"].shift(1440)
+
+    for chg in [1, 6, 24, 168, 336, 720, 1440]:
         df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
 
     df["ma_24h_raw"] = df.groupby(group_cols)["avg_price"].transform(
@@ -357,13 +357,6 @@ 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()
     )
@@ -381,7 +374,6 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     )
     df["volume_ratio"] = df["item_count"] / df["volume_ma_24h"].replace(0, np.nan)
 
-    # 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)
     )
@@ -397,27 +389,25 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     )
     df["is_downtrend"] = ((df["chg_6h"] < 0) & (df["chg_24h"] < 0)).astype(int)
 
-    df = _compute_forward_targets(df)
+    df = _compute_targets(df)
     return df
 
 
-def _compute_forward_targets(df: pd.DataFrame) -> pd.DataFrame:
+def _compute_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_24h"] = np.nan
-        df["target_log_return_90d"] = np.nan
-        df["target_class_90d"] = np.nan
+        for c in ["target_log_return_24h", "target_class_24h",
+                  "target_log_return_30d", "target_class_30d"]:
+            df[c] = np.nan
         return df
 
     df["target_log_return_24h"] = np.nan
-    df["target_log_return_90d"] = np.nan
+    df["target_log_return_30d"] = np.nan
 
     group_cols = ["item_id", "city", "quality"]
 
-    for keys, g in df.groupby(group_cols):
+    for _, g in df.groupby(group_cols):
         if len(g) < 5:
             continue
-
         g = g.sort_values("timestamp")
         left = pd.DataFrame({
             "timestamp": g["timestamp"].values,
@@ -429,43 +419,39 @@ def _compute_forward_targets(df: pd.DataFrame) -> pd.DataFrame:
             "log_price_future": g["log_price"].values,
         }).sort_values("timestamp")
 
-        # 24 saat
+        # 24h
         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),
+            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
         )
 
-        # 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"),
+        # 30g
+        left["target_t_30d"] = left["timestamp"] + pd.Timedelta(days=HORIZON_DAYS_30D)
+        m30 = pd.merge_asof(
+            left.sort_values("target_t_30d"),
             right.sort_values("timestamp"),
-            left_on="target_t_90d",
-            right_on="timestamp",
-            direction="nearest",
-            tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_90D),
+            left_on="target_t_30d", right_on="timestamp",
+            direction="nearest", tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_30D),
             suffixes=("", "_f"),
         )
-        df.loc[m90["idx"].values, "target_log_return_90d"] = (
-            m90["log_price_future"].values - m90["log_price_now"].values
+        df.loc[m30["idx"].values, "target_log_return_30d"] = (
+            m30["log_price_future"].values - m30["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
 
-    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
+    t30 = df["target_log_return_30d"]
+    df["target_class_30d"] = np.where(t30 < CLASS_DOWN_30D, 0, np.where(t30 > CLASS_UP_30D, 2, 1))
+    df.loc[t30.isna(), "target_class_30d"] = np.nan
 
     return df
 
@@ -502,12 +488,11 @@ def enrich_spread_features(featured_df: pd.DataFrame, prices_df: pd.DataFrame) -
 
 
 # ---------------------------------------------------------------------------
-# MODEL EĞİTİMİ (24h + 90d)
+# MODEL EĞİTİMİ
 # ---------------------------------------------------------------------------
 
 
 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()
 
@@ -524,9 +509,8 @@ def _prepare_model_df(featured_df: pd.DataFrame, horizon: str) -> Tuple[pd.DataF
     df = df.dropna(subset=[target_col]).copy()
     df[target_col] = df[target_col].astype(int)
 
-    # Doldur
-    fill_cols = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
-    for c in fill_cols:
+    fill_chg = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
+    for c in fill_chg:
         if c in df.columns:
             df[c] = df[c].fillna(0.0)
 
@@ -534,22 +518,20 @@ def _prepare_model_df(featured_df: pd.DataFrame, horizon: str) -> Tuple[pd.DataF
         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)
+    df["rsi_14"] = df["rsi_14"].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]
-
-    model_df = df.dropna(subset=feature_cols + [target_col]).copy()
+    fcols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_30D
+    fcols = [c for c in fcols if c in df.columns]
+    model_df = df.dropna(subset=fcols + [target_col]).copy()
     if model_df.empty:
         return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
 
-    X = model_df[feature_cols].astype("float64")
+    X = model_df[fcols].astype("float64")
     y = model_df[target_col]
     meta = model_df[["item_id", "city", "quality", "timestamp", "avg_price"]].copy()
     return X, y, meta
@@ -560,8 +542,10 @@ def train_model(X: pd.DataFrame, y: pd.Series, horizon: str) -> Optional[lgb.LGB
         return None
     cc = y.value_counts().to_dict()
     print(f"[{horizon}] sınıf: {cc}")
-    if len(cc) < 3 or min(cc.values()) < 10:
+    if len(cc) < 2:
         return None
+    if len(cc) < 3:
+        print(f"[{horizon}] UYARI: sadece {len(cc)} sınıf var")
 
     split = int(len(X) * 0.8)
     X_tr, X_val = X.iloc[:split], X.iloc[split:]
@@ -577,13 +561,16 @@ def train_model(X: pd.DataFrame, y: pd.Series, horizon: str) -> Optional[lgb.LGB
         reg_alpha=0.5, reg_lambda=1.0,
         verbose=-1, random_state=42, n_jobs=-1,
     )
-    model.fit(
-        X_tr, y_tr,
-        eval_set=[(X_val, y_val)],
-        callbacks=[lgb.early_stopping(30, verbose=False), lgb.log_evaluation(0)],
-    )
-    acc = accuracy_score(y_val, model.predict(X_val))
-    print(f"[{horizon}] val_accuracy={acc:.4f}")
+    try:
+        model.fit(
+            X_tr, y_tr, eval_set=[(X_val, y_val)],
+            callbacks=[lgb.early_stopping(30, verbose=False), lgb.log_evaluation(0)],
+        )
+        acc = accuracy_score(y_val, model.predict(X_val))
+        print(f"[{horizon}] val_accuracy={acc:.4f}")
+    except Exception as e:
+        print(f"[{horizon}] eğitim hatası: {e}")
+        return None
     return model
 
 
@@ -597,24 +584,22 @@ def predict(model, latest_features: pd.DataFrame, horizon: str) -> pd.DataFrame:
     if "qual_code" not in df.columns:
         df["qual_code"] = df.get("quality", 1)
 
-    fill_cols = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
-    for c in fill_cols:
+    for c in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]:
         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)
+    df["rsi_14"] = df["rsi_14"].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()
+    fcols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_30D
+    fcols = [c for c in fcols if c in df.columns]
+    X_ready = df[fcols].astype("float64").dropna()
     if X_ready.empty:
         return pd.DataFrame()
 
@@ -625,19 +610,19 @@ def predict(model, latest_features: pd.DataFrame, horizon: str) -> pd.DataFrame:
         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)
+        exp_log = probs[:, 0] * CLASS_DOWN_30D + probs[:, 2] * CLASS_UP_30D
+        clipped = np.clip(exp_log, CLASS_DOWN_30D, CLASS_UP_30D)
 
     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",
+            "is_downtrend", "chg_6h", "chg_24h", "chg_168h", "trend_slope_30d",
             "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["prob_flat"] = probs[:, 1] if probs.shape[1] > 1 else 0.0
+    out["prob_up"] = probs[:, 2] if probs.shape[1] > 2 else 0.0
     out["predicted_log_return"] = clipped
     out["predicted_return_pct"] = (np.exp(clipped) - 1) * 100
     out["predicted_price"] = out["avg_price"] * np.exp(clipped)
@@ -645,6 +630,45 @@ def predict(model, latest_features: pd.DataFrame, horizon: str) -> pd.DataFrame:
     return out
 
 
+# ---------------------------------------------------------------------------
+# TREND PROJEKSİYONU (30d model yoksa fallback)
+# ---------------------------------------------------------------------------
+
+
+def trend_projection_90d(latest: pd.DataFrame) -> pd.DataFrame:
+    """
+    30d model yoksa, trend_slope_30d kullanarak 90 günlük basit projeksiyon.
+    Formül: fiyat × exp(slope × gün_sayısı)
+    slope günlük log değişim → 90 günde slope × 90
+    """
+    if latest.empty:
+        return pd.DataFrame()
+
+    df = latest.copy()
+    df["trend_slope_30d"] = df.get("trend_slope_30d", pd.Series(0.0, index=df.index)).fillna(0.0)
+
+    # slope * 90 gün = 90 günlük log getiri
+    log_return_90d = df["trend_slope_30d"] * TREND_PROJECTION_DAYS
+
+    # Aşırı projeksiyonu clip'le (90 günde ±%100)
+    log_return_90d = np.clip(log_return_90d, -1.0, 1.0)
+
+    df["predicted_log_return"] = log_return_90d
+    df["predicted_return_pct"] = (np.exp(log_return_90d) - 1) * 100
+    df["predicted_price"] = df["avg_price"] * np.exp(log_return_90d)
+
+    # Güven: trend gücüne göre
+    df["confidence"] = np.abs(df["trend_slope_30d"]).clip(0, 0.005) / 0.005 * 0.6 + 0.3
+
+    df["pred_class"] = np.where(log_return_90d < -0.05, 0,
+                          np.where(log_return_90d > 0.05, 2, 1))
+    df["prob_up"] = np.where(log_return_90d > 0.05, 0.6, 0.2)
+    df["prob_down"] = np.where(log_return_90d < -0.05, 0.6, 0.2)
+    df["prob_flat"] = 1.0 - df["prob_up"] - df["prob_down"]
+
+    return df
+
+
 # ---------------------------------------------------------------------------
 # DİP SİNYALİ
 # ---------------------------------------------------------------------------
@@ -654,39 +678,28 @@ 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}")
+        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}")
+        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}")
+        passed += 1; reasons.append(f"H×{vr:.1f}")
     pp = row.get("predicted_return_pct", 0)
     if pd.notna(pp) and pp >= DIP_MIN_PREDICTED_PCT:
-        passed += 1
-        reasons.append(f"M={pp:+.1f}%")
+        passed += 1; 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={sp*100:.1f}%")
+        passed += 1; 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✓")
-
-    if passed >= 5:
-        sig = "🟢 GÜÇLÜ AL"
-    elif passed == 4:
-        sig = "🟡 ZAYIF AL"
-    elif passed == 3 and pd.notna(rsi) and rsi < 45:
-        sig = "🔵 İZLE"
-    elif down and pd.notna(pp) and pp < -2:
-        sig = "🔴 ALMA"
-    else:
-        sig = "⚪ BEKLE"
+        passed += 1; reasons.append("Trend✓")
+
+    if passed >= 5: sig = "🟢 GÜÇLÜ AL"
+    elif passed == 4: sig = "🟡 ZAYIF AL"
+    elif passed == 3 and pd.notna(rsi) and rsi < 45: sig = "🔵 İZLE"
+    elif down and pd.notna(pp) and pp < -2: sig = "🔴 ALMA"
+    else: sig = "⚪ BEKLE"
     return sig, " · ".join(reasons) if reasons else "—"
 
 
@@ -701,18 +714,19 @@ class DataPipeline:
         self.prices_df = pd.DataFrame()
         self.featured_df = pd.DataFrame()
         self.model_24h = None
-        self.model_90d = None
+        self.model_30d = None
         self.last_update = None
         self.status_message = "Veri yüklenmedi."
         self._diagnostics = {}
+        self._projection_mode = "MODEL"  # veya "TREND"
 
         if _HAS_JOBLIB:
             try:
                 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:
+                if os.path.exists(MODEL_PATH_30D):
+                    self.model_30d = joblib.load(MODEL_PATH_30D)
+                if self.model_24h or self.model_30d:
                     self.status_message = "Kayıtlı model(ler) yüklendi."
             except Exception:
                 pass
@@ -721,7 +735,7 @@ class DataPipeline:
         item_ids = item_ids or ITEM_IDS
         cities = cities or CITIES
 
-        self.status_message = "Public API'den veri çekiliyor (3 kalite)..."
+        self.status_message = "Public API'den veri çekiliyor..."
         ok, msg = check_api_health()
         if not ok:
             self.status_message = f"API erişilemiyor: {msg}"
@@ -740,7 +754,7 @@ class DataPipeline:
 
         self.history_df = clean_market_data(hist)
         self.prices_df = prices
-        n_q = self.history_df["quality"].nunique() if "quality" in self.history_df.columns else 1
+        n_q = self.history_df["quality"].nunique()
         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")
@@ -755,18 +769,21 @@ class DataPipeline:
         if df.empty:
             self._diagnostics = {}
             return
-        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
+        n24 = int(df["target_class_24h"].notna().sum())
+        n30 = int(df["target_class_30d"].notna().sum())
         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 {}
+        cd30 = df["target_class_30d"].value_counts().to_dict() if n30 > 0 else {}
+        date_range_days = (df["timestamp"].max() - df["timestamp"].min()).days if len(df) > 0 else 0
+
         self._diagnostics = {
             "n_total": len(df),
             "n_24h": n24,
-            "n_90d": n90,
+            "n_30d": n30,
             "class_24h": cd24,
-            "class_90d": cd90,
+            "class_30d": cd30,
+            "date_range_days": date_range_days,
         }
-        print(f"[TANI] total={len(df)}, 24h={n24}, 90d={n90}")
+        print(f"[TANI] total={len(df)}, 24h={n24}, 30d={n30}, gün={date_range_days}")
 
     def train_all(self):
         if self.featured_df.empty:
@@ -783,30 +800,32 @@ class DataPipeline:
                 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:
+        # 30d
+        X30, y30, _ = _prepare_model_df(self.featured_df, "30d")
+        n30 = len(X30)
+        if n30 >= MIN_TRAIN_SAMPLES:
+            self.model_30d = train_model(X30, y30, "30d")
+            if _HAS_JOBLIB and self.model_30d:
                 try:
-                    joblib.dump(self.model_90d, MODEL_PATH_90D)
+                    joblib.dump(self.model_30d, MODEL_PATH_30D)
                 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)")
+        # Projeksiyon modu belirle
+        if self.model_30d is not None:
+            self._projection_mode = "MODEL"
         else:
-            msgs.append(f"90d✗ (yetersiz: {n90})")
+            self._projection_mode = "TREND"
 
-        self.status_message = "Model: " + " · ".join(msgs)
+        msgs = []
+        msgs.append("24h ✓" if self.model_24h else "24h ✗")
+        if self.model_30d:
+            msgs.append(f"30d ✓ ({n30})")
+        else:
+            msgs.append(f"30d ✗ ({n30}) → trend projeksiyonu")
+        self.status_message = " · ".join(msgs)
         self.last_update = dt.datetime.now()
-        return self.model_24h is not None or self.model_90d is not None
+        return True
 
     def get_latest(self) -> pd.DataFrame:
         if self.featured_df.empty:
@@ -839,11 +858,18 @@ class DataPipeline:
         preds["Sinyal Detayı"] = dip[1]
         return preds
 
-    def predict_90d(self) -> pd.DataFrame:
+    def predict_long_horizon(self) -> Tuple[pd.DataFrame, str]:
+        """30d model varsa model, yoksa trend projeksiyonu."""
         latest = self.get_latest()
-        if latest.empty or self.model_90d is None:
-            return pd.DataFrame()
-        return predict(self.model_90d, latest, "90d")
+        if latest.empty:
+            return pd.DataFrame(), "veri_yok"
+
+        if self.model_30d is not None:
+            preds = predict(self.model_30d, latest, "30d")
+            return preds, "model_30d"
+        else:
+            preds = trend_projection_90d(latest)
+            return preds, "trend_projection"
 
 
 pipeline = DataPipeline()
@@ -862,14 +888,15 @@ def get_dashboard_metrics():
     df = pipeline.featured_df
     m = {
         "Veri Kaynağı": "Public AODP API",
+        "Veri Süresi": f"{diag.get('date_range_days', 0)} gün",
         "Toplam Gözlem": len(df),
         "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()}",
+        "Hedefli 30d": diag.get("n_30d", 0),
+        "Sınıf 24h": str(diag.get("class_24h", {})),
+        "Sınıf 30d": str(diag.get("class_30d", {})),
+        "24h Model": "Eğitildi" if pipeline.model_24h else "Yok",
+        "30d Model": "Eğitildi" if pipeline.model_30d else "Yok",
+        "Uzun Vadeli Mod": pipeline._projection_mode,
         "Son Güncelleme": pipeline.last_update.strftime("%Y-%m-%d %H:%M") if pipeline.last_update else "—",
     }
     return pd.DataFrame(list(m.items()), columns=["Metrik", "Değer"])
@@ -879,46 +906,51 @@ 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["24s"] = 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"]
+    cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "24s", "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()
+def get_prediction_long_table():
+    preds, mode = pipeline.predict_long_horizon()
     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."
-        ]})
+        return pd.DataFrame({"Bilgi": ["Uzun vadeli tahmin yok."]}), mode
 
     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)
+    if mode == "model_30d":
+        preds["30 Gün 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", "30 Gün Tahmini",
+                "Değişim %", "Trend", "P(↑)", "Güven"]
+    else:
+        # Trend projeksiyon
+        preds["90 Gün 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["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
+        cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "90 Gün Tahmini",
+                "Değişim %", "Trend", "Güven"]
+
+    return preds[cols].sort_values("Güven", ascending=False), mode
 
 
 def get_analysis_table():
@@ -945,7 +977,6 @@ def get_analysis_table():
     latest["RSI"] = latest["rsi_14"].round(0)
     latest["7g%"] = (latest["price_pct_7d"] * 100).round(0)
     latest["30g Trend"] = latest["trend_slope_30d"].round(4)
-
     cols = ["Ürün", "Kalite", "Şehir", "Fiyat", "Hacim", "Spread",
             "RSI", "7g%", "30g Trend"]
     return latest[cols].sort_values("Hacim", ascending=False).head(100)
@@ -970,7 +1001,6 @@ def get_dip_table():
     dip["P(↑)"] = (dip["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
     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",
             "RSI", "7g%", "P(↑)", "Net %", "Sinyal Detayı"]
     return dip[cols].head(50)
@@ -1020,13 +1050,12 @@ def get_arbitrage_table():
     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_importance_plot(horizon: str = "24h"):
-    model = pipeline.model_24h if horizon == "24h" else pipeline.model_90d
+    model = pipeline.model_24h if horizon == "24h" else pipeline.model_30d
     if model is None:
         return go.Figure().update_layout(title=f"{horizon} model yok", template="plotly_dark")
     try:
@@ -1069,22 +1098,29 @@ def refresh_all():
         import traceback
         traceback.print_exc()
 
+    try:
+        long_table, long_mode = get_prediction_long_table()
+    except Exception:
+        long_table, long_mode = pd.DataFrame(), "error"
+
     def _safe(fn, default):
         try:
             return fn()
         except Exception:
             return default
 
+    mode_msg = f"Uzun vade: {'MODEL (30d)' if long_mode == 'model_30d' else 'TREND PROJEKSİYONU (90d)'}"
+
     return (
-        pipeline.status_message,
+        f"{pipeline.status_message} | {mode_msg}",
         _safe(get_dashboard_metrics, pd.DataFrame()),
         _safe(get_analysis_table, pd.DataFrame()),
         _safe(get_prediction_24h_table, pd.DataFrame()),
-        _safe(get_prediction_90d_table, pd.DataFrame()),
+        long_table,
         _safe(get_dip_table, pd.DataFrame()),
         _safe(get_arbitrage_table, pd.DataFrame()),
         _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(lambda: get_importance_plot("30d"), go.Figure().update_layout(title="—", template="plotly_dark")),
         _safe(list_csv_files, pd.DataFrame()),
     )
 
@@ -1095,10 +1131,10 @@ def initial_load():
             return fn()
         except Exception:
             return default
-
     return (
         _safe(get_dashboard_metrics, pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})),
-        pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
+        pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
+        pd.DataFrame({"Bilgi": ["Yenile'ye basın"]}),
         pd.DataFrame(), pd.DataFrame(),
         go.Figure().update_layout(title="Yenile", template="plotly_dark"),
         go.Figure().update_layout(title="Yenile", template="plotly_dark"),
@@ -1115,68 +1151,67 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
 
     gr.Markdown(
         """
-        # 🦅 GOSHAWK ALBION MARKET AI v3.0
-        **Çok ufuklu tahmin:** 24 saat + 3 ay (90 gün) | Avrupa Sunucusu
+        # 🦅 GOSHAWK ALBION MARKET AI v3.1
+        **Hibrit yaklaşım:** 24h model + 30d model (yoksa 90d trend projeksiyonu)
 
-        **⚠️ 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.
+        **⚠️ Uyarı:** Uzun vadeli tahmin **düşük güvenilirlikte**. Trend yönü için kullanın.
         """
     )
 
     with gr.Row():
-        refresh_btn = gr.Button("🔄 Verileri Yenile ve Modelleri Eğit", variant="primary", scale=1)
+        refresh_btn = gr.Button("🔄 Verileri Yenile", 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)
+            dashboard_table = gr.Dataframe(label="Özet & Teşhis", interactive=False, wrap=True)
             gr.Markdown(
-                "### İ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"
-                "- 3 aylık tahmin = düşük güven\n"
-                "- Model bir önceki dönemi öğrenir, geleceği değil"
+                "### Hibrit Yaklaşım\n"
+                "**24h Model:** Her zaman denenir\n"
+                "**30d Model:** Yeterli veri varsa (min 150 örnek) eğitilir\n"
+                "**Trend Projeksiyonu:** 30d model yoksa, 30 günlük lineer trend eğiminden 90 günlük tahmin\n\n"
+                "### Neden 30d, 90d değil?\n"
+                "- 90d model için **6 ay geçmiş veri** gerekir\n"
+                "- API'de genelde 2-4 ay var → 90d model eğitilemez\n"
+                "- 30d model için **2 ay geçmiş** yeterli → çoğu üründe çalışır\n\n"
+                "### Trend Projeksiyonu Formülü\n"
+                "`fiyat × exp(trend_slope_30d × 90 gün)`\n"
+                "- Basit ama az veriyle çalışır\n"
+                "- Patch/sezon değişimini **görmez**"
             )
 
-        with gr.TabItem("🔮 24 Saat Tahmin"):
+        with gr.TabItem("🔮 24 Saat"):
             pred_24h_table = gr.Dataframe(label="24s Tahminler", interactive=False)
 
-        with gr.TabItem("📅 3 Aylık Tahmin"):
-            pred_90d_table = gr.Dataframe(label="90 Gün Tahminler", interactive=False)
+        with gr.TabItem("📅 Uzun Vade"):
+            pred_long_table = gr.Dataframe(label="30 Gün Modeli veya 90 Gün Trend Projeksiyonu", 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.***"
+                "*30d model eğitildiyse 30 günlük tahmin, aksi halde 30 günlük trendden 90 günlük projeksiyon. "
+                "**Güven %50 altındaysa işlem yapmayın.** Patch değişimleri modeli tamamen bozar.*"
             )
 
         with gr.TabItem("🎯 DİP ALIM"):
-            dip_table = gr.Dataframe(label="Dip Alım Sinyalleri (24h)", interactive=False)
+            dip_table = gr.Dataframe(label="Dip Alım", interactive=False)
 
         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)
+            arbitrage_table = gr.Dataframe(label="Arbitraj", interactive=False)
 
         with gr.TabItem("📈 24h Model"):
-            importance_24h = gr.Plot(label="24h Feature Importance")
+            importance_24h = gr.Plot(label="24h Önem")
 
-        with gr.TabItem("📈 90d Model"):
-            importance_90d = gr.Plot(label="90d Feature Importance")
+        with gr.TabItem("📈 30d Model"):
+            importance_30d = gr.Plot(label="30d Önem")
 
         with gr.TabItem("🗄️ Veri"):
             gr.Markdown(
                 "**API:** europe.albion-online-data.com\n"
-                "**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}"
+                "**Kalite:** 1-3\n"
+                f"**24h sınır:** ±%{CLASS_UP_24H*100:.0f}\n"
+                f"**30d sınır:** ±%{CLASS_UP_30D*100:.0f}\n"
+                f"**Trend projeksiyon:** {TREND_PROJECTION_DAYS} gün"
             )
             csv_files = gr.Dataframe(label="CSV", interactive=False,
                                      headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])
@@ -1185,15 +1220,15 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
         fn=refresh_all,
         inputs=[],
         outputs=[status_text, dashboard_table, analysis_table, pred_24h_table,
-                 pred_90d_table, dip_table, arbitrage_table, importance_24h,
-                 importance_90d, csv_files],
+                 pred_long_table, dip_table, arbitrage_table, importance_24h,
+                 importance_30d, csv_files],
     )
 
     demo.load(
         fn=initial_load,
         inputs=[],
-        outputs=[dashboard_table, analysis_table, pred_24h_table, pred_90d_table,
-                 dip_table, arbitrage_table, importance_24h, importance_90d, csv_files],
+        outputs=[dashboard_table, analysis_table, pred_24h_table, pred_long_table,
+                 dip_table, arbitrage_table, importance_24h, importance_30d, csv_files],
     )