#!/usr/bin/env python3 """ train_ranker.py — LGBMRanker walk-forward training for Jinjing V2 Fire Eye v8. Reads ranking training data (parquet), trains on walk-forward windows, evaluates NDCG and Rank IC, saves model and predictions. """ import argparse import os import sys import warnings from pathlib import Path import numpy as np import pandas as pd import pyarrow.parquet as pq from scipy.stats import spearmanr import lightgbm as lgb from typing import Optional warnings.filterwarnings("ignore") # --------------------------------------------------------------------------- # Constants # --------------------------------------------------------------------------- # Columns that should never be treated as features NON_FEATURE_COLS = { "date", "symbol", "query_group", "label", "label_rank", "forward_20d_ret", "trend_type", # Prediction columns — only in predictions parquet, not in training data "pred_rank", } TARGET_COL = "label_rank" # 1-10 decile of forward_20d_ret (10 = highest forward return) # Will be set dynamically after loading data FEATURE_COLS: list[str] = [] QUERY_GROUP_COL = "query_group" DATE_COL = "date" SYMBOL_COL = "symbol" WINDOWS = [ ("2018-01-01", "2022-11-30", "2023-01-01", "2024-06-30"), ("2018-06-01", "2023-06-01", "2023-07-01", "2024-12-31"), ("2019-01-01", "2024-05-31", "2024-07-01", "2025-06-30"), ("2019-06-01", "2024-12-31", "2025-01-01", "2025-12-31"), ("2020-01-01", "2024-12-31", "2025-01-01", "2026-04-10"), ] RANKER_PARAMS = { "objective": "lambdarank", "boosting_type": "gbdt", "metric": "ndcg", "ndcg_eval_at": [20, 50], "num_leaves": 63, "learning_rate": 0.05, "min_data_in_leaf": 100, "feature_fraction": 0.6, # 0.6: reduced from 0.8 — force diverse feature usage (P2 fix) "subsample": 0.8, # row subsampling for generalization (P2 fix) "subsample_freq": 1, # resample every iteration (P2 fix) "lambda_l1": 0.1, # L1 regularization — sparsify weak features (P2 fix) "lambda_l2": 1.0, # L2 regularization — prevent single-feature dominance (P2 fix) "verbosity": -1, } NUM_BOOST_ROUND = 300 EARLY_STOPPING_ROUNDS = 50 # ── PRISM-VQ prior factor columns ── PRIOR_FACTOR_NAMES = [ "momentum_12m", "reversal_1m", "volatility_idio", "beta_60d", "turnover_avg", "size", "pe", "pb", "ps", "dividend_yield", "roe", "gross_margin", "asset_growth", ] PRIOR_PREFIXES = ["prior_"] MODEL_VERSION = "v9" # bump from v8 for prior factor support # --------------------------------------------------------------------------- # helpers # --------------------------------------------------------------------------- def infer_feature_cols(df: pd.DataFrame) -> list[str]: """Auto-detect feature columns. Excludes known non-feature columns (date, symbol, query_group, label, etc.) and any non-numeric columns. Returns only numeric feature columns. """ candidates = list(df.columns) candidates = [c for c in candidates if c not in NON_FEATURE_COLS] numeric_cols = [c for c in candidates if pd.api.types.is_numeric_dtype(df[c])] if not numeric_cols: print("ERROR: No numeric feature columns found after auto-detection") print(f" Available columns: {list(df.columns)}") sys.exit(1) print(f"[features] Auto-detected {len(numeric_cols)} feature columns") return numeric_cols def load_data(data_path: str, sample: Optional[int] = None) -> pd.DataFrame: """Load parquet from *data_path* or fallback to HuggingFace dataset. Auto-detects feature columns and sets the module-level FEATURE_COLS. """ global FEATURE_COLS path = Path(data_path) if path.exists(): print(f"[data] Loading local parquet: {path}") df = pd.read_parquet(path) else: print(f"[data] Local path not found, trying HuggingFace dataset...") hf_token = os.environ.get("HF_TOKEN") if not hf_token: print("ERROR: HF_TOKEN environment variable not set") sys.exit(1) from huggingface_hub import hf_hub_download parquet_path = hf_hub_download( repo_id="cedwyh/jinjing-shared-data", filename="ranking_train_data_v3.parquet", repo_type="dataset", token=hf_token, ) df = pd.read_parquet(parquet_path) print(f"[data] Loaded {len(df):,} rows, {len(df.columns)} columns") # Create query_group if missing (sequential int per date for lambdarank) if QUERY_GROUP_COL not in df.columns: print(f"[data] Creating {QUERY_GROUP_COL} column...") dates = df[DATE_COL].unique() date_map = {d: i for i, d in enumerate(sorted(dates))} df[QUERY_GROUP_COL] = df[DATE_COL].map(date_map) print(f"[data] Created {len(dates)} query groups from dates") # Ensure required columns exist for col in [TARGET_COL, DATE_COL, QUERY_GROUP_COL, SYMBOL_COL]: if col not in df.columns: print(f"ERROR: Required column '{col}' not found in data") print(f" Available columns: {list(df.columns)}") sys.exit(1) # Optionally sample if sample is not None and sample < len(df): df = df.sample(n=sample, random_state=42).reset_index(drop=True) print(f"[data] Sampled to {len(df):,} rows") # Auto-detect feature columns FEATURE_COLS = infer_feature_cols(df) # Ensure types df[DATE_COL] = pd.to_datetime(df[DATE_COL]).dt.date df[FEATURE_COLS] = df[FEATURE_COLS].astype(np.float32) df[TARGET_COL] = df[TARGET_COL].astype(np.int32) df[QUERY_GROUP_COL] = df[QUERY_GROUP_COL].astype(np.int32) return df def build_query_groups(df: pd.DataFrame) -> np.ndarray: """Build group array for LGBMRanker: counts of samples per query (date).""" counts = df.groupby(DATE_COL, observed=True).size().values return counts.astype(np.int32) def _dcg(scores: np.ndarray, k: int) -> float: """Discounted Cumulative Gain @ k.""" scores = scores[:k] # gain = 2^rel - 1 (rel is the label_rank 1..10) gains = np.power(2.0, scores) - 1.0 denom = np.log2(np.arange(2, len(scores) + 2)) return float(np.sum(gains / denom)) def evaluate_ndcg(y_true: np.ndarray, y_pred: np.ndarray, groups: np.ndarray, k: int) -> float: """Compute average NDCG@k across query groups.""" ndcgs = [] idx = 0 for g in groups: if g < 2: idx += g continue true_chunk = y_true[idx: idx + g].astype(np.float64) pred_chunk = y_pred[idx: idx + g] # Sort true by prediction descending order = np.argsort(pred_chunk)[::-1] ranked_true = true_chunk[order] # Ideal order ideal = np.sort(true_chunk)[::-1] dcg_val = _dcg(ranked_true, k) idcg_val = _dcg(ideal, k) if idcg_val > 0: ndcgs.append(dcg_val / idcg_val) idx += g return float(np.mean(ndcgs)) if ndcgs else 0.0 def evaluate_rank_ic( y_true: np.ndarray, y_pred: np.ndarray, groups: np.ndarray ) -> float: """Spearman correlation between predicted and actual ranks, averaged across queries.""" ics = [] idx = 0 for g in groups: if g < 2: idx += g continue true_chunk = y_true[idx: idx + g] pred_chunk = y_pred[idx: idx + g] # If all same values, skip if len(np.unique(true_chunk)) < 2 or len(np.unique(pred_chunk)) < 2: idx += g continue rho, _ = spearmanr(true_chunk, pred_chunk) if not np.isnan(rho): ics.append(rho) idx += g return float(np.mean(ics)) if ics else 0.0 def train_window( train_df: pd.DataFrame, val_df: pd.DataFrame, window_idx: int, window_label: str, ) -> tuple: """Train LGBMRanker on one walk-forward window and return (model, preds_df).""" print(f"\n{'='*60}") print(f"Window {window_idx + 1}: {window_label}") print(f"{'='*60}") # Train data X_train = train_df[FEATURE_COLS].values y_train = train_df[TARGET_COL].values train_groups = build_query_groups(train_df) print(f" Train: {len(train_df):,} rows, {len(train_groups)} dates") # Validation data X_val = val_df[FEATURE_COLS].values y_val = val_df[TARGET_COL].values val_groups = build_query_groups(val_df) print(f" Val: {len(val_df):,} rows, {len(val_groups)} dates") # Datasets — MUST pass feature_name so the saved model stores real column names, # not generic Column_0..Column_N (Bug 1 fix). # This enables post-hoc feature importance mapping and correct feature alignment # in predict.py (Layer 1 of the Schema Contract). train_data = lgb.Dataset(X_train, label=y_train, group=train_groups, feature_name=FEATURE_COLS) val_data = lgb.Dataset(X_val, label=y_val, group=val_groups, reference=train_data) # Train model = lgb.train( RANKER_PARAMS, train_data, valid_sets=[val_data], num_boost_round=NUM_BOOST_ROUND, callbacks=[ lgb.early_stopping(EARLY_STOPPING_ROUNDS), lgb.log_evaluation(50), ], ) # Predictions on validation set val_pred = model.predict(X_val) val_df = val_df.copy() val_df["pred_rank"] = val_pred # Evaluate ndcg_20 = evaluate_ndcg(y_val, val_pred, val_groups, 20) ndcg_50 = evaluate_ndcg(y_val, val_pred, val_groups, 50) rank_ic = evaluate_rank_ic(y_val, val_pred, val_groups) print(f" Results -> NDCG@20: {ndcg_20:.4f}, NDCG@50: {ndcg_50:.4f}, Rank IC: {rank_ic:.4f}") print(f" Best iteration: {model.best_iteration}") return model, val_df, ndcg_20, ndcg_50, rank_ic # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser( description=f"Train LGBMRanker for Jinjing V2 Fire Eye {MODEL_VERSION} ranking model" ) parser.add_argument( "--data", type=str, default=None, help=( "Path to local parquet file. If not provided, tries " "/tmp/ranking_train_data.parquet then HF dataset." ), ) parser.add_argument( "--output", type=str, default="/tmp", help="Output directory for model and predictions (default: /tmp)", ) parser.add_argument( "--sample", type=int, default=None, help="Random subset of rows for fast testing", ) parser.add_argument( "--use-priors", action=argparse.BooleanOptionalAction, default=True, help="Enable PRISM-VQ prior_* feature columns (default: True)", ) args = parser.parse_args() # Determine data path data_path = args.data if data_path is None: default_local = "/tmp/ranking_train_data.parquet" if os.path.exists(default_local): data_path = default_local else: data_path = default_local # will trigger HF fallback in load_data # Load df = load_data(data_path, sample=args.sample) print(f"[data] Date range: {df[DATE_COL].min()} to {df[DATE_COL].max()}") print(f"[data] Unique dates: {df[DATE_COL].nunique()}, symbols: {df[SYMBOL_COL].nunique()}") # ── Handle prior_* feature columns ── prior_cols_in_data = sorted([c for c in df.columns if c.startswith("prior_")]) if args.use_priors and prior_cols_in_data: print(f"[priors] Found {len(prior_cols_in_data)} prior_* columns in data: {prior_cols_in_data}") elif args.use_priors and not prior_cols_in_data: print("[priors] No prior_* columns found in data (running without priors)") elif not args.use_priors and prior_cols_in_data: print(f"[priors] --use-priors=False: excluding {len(prior_cols_in_data)} prior_* columns from features") # Remove prior columns from FEATURE_COLS global FEATURE_COLS FEATURE_COLS = [c for c in FEATURE_COLS if not c.startswith("prior_")] print(f"[features] After prior exclusion: {len(FEATURE_COLS)} feature columns") else: print("[priors] No prior columns and --use-priors=False: nothing to do") # Also track baseline features (without priors) for IC comparison later non_prior_feature_cols = [c for c in FEATURE_COLS if not c.startswith("prior_")] has_priors = args.use_priors and len(prior_cols_in_data) > 0 and len(non_prior_feature_cols) < len(FEATURE_COLS) # Deduplicate (data may have multiple rows per date-symbol from concatenated windows) before = len(df) df = df.drop_duplicates(subset=[DATE_COL, SYMBOL_COL]).reset_index(drop=True) after = len(df) if after < before: print(f"[data] Deduplicated: {before:,} → {after:,} rows ({before - after:,} duplicates removed)") # Walk-forward training all_predictions = [] results = [] best_model = None for idx, (train_start, train_end, val_start, val_end) in enumerate(WINDOWS): train_start_ts = pd.Timestamp(train_start).date() train_end_ts = pd.Timestamp(train_end).date() val_start_ts = pd.Timestamp(val_start).date() val_end_ts = pd.Timestamp(val_end).date() train_mask = (df[DATE_COL] >= train_start_ts) & (df[DATE_COL] <= train_end_ts) val_mask = (df[DATE_COL] >= val_start_ts) & (df[DATE_COL] <= val_end_ts) train_df = df.loc[train_mask].reset_index(drop=True) val_df = df.loc[val_mask].reset_index(drop=True) if len(train_df) == 0 or len(val_df) == 0: print(f"\n[skip] Window {idx+1}: no data in train or val range, skipping") continue label = f"{train_start}..{train_end} => {val_start}..{val_end}" model, pred_df, ndcg_20, ndcg_50, rank_ic = train_window( train_df, val_df, idx, label, ) all_predictions.append(pred_df) results.append( { "window": idx + 1, "train_range": f"{train_start} -> {train_end}", "val_range": f"{val_start} -> {val_end}", "NDCG@20": ndcg_20, "NDCG@50": ndcg_50, "Rank IC": rank_ic, "best_iteration": model.best_iteration, "n_train": len(train_df), "n_val": len(val_df), } ) best_model = model # keep last window model # Summary table print(f"\n{'='*80}") print("SUMMARY") print(f"{'='*80}") print(f"{'Window':>6} | {'NDCG@20':>8} | {'NDCG@50':>8} | {'Rank IC':>8} | Best Iter | Train Rows | Val Rows") print("-" * 80) avg_ndcg20, avg_ndcg50, avg_rankic = 0.0, 0.0, 0.0 for r in results: print( f"{r['window']:>6} | {r['NDCG@20']:>8.4f} | {r['NDCG@50']:>8.4f} | " f"{r['Rank IC']:>8.4f} | {r['best_iteration']:>9} | {r['n_train']:>10,} | {r['n_val']:>8,}" ) avg_ndcg20 += r["NDCG@20"] avg_ndcg50 += r["NDCG@50"] avg_rankic += r["Rank IC"] n = len(results) if n > 0: avg_ndcg20 /= n avg_ndcg50 /= n avg_rankic /= n print("-" * 80) print( f"{'AVG':>6} | {avg_ndcg20:>8.4f} | {avg_ndcg50:>8.4f} | " f"{avg_rankic:>8.4f} | {'':>9} | {'':>10} | {'':>8}" ) print(f"{'='*80}\n") # Concat all predictions before saving / uploading all_pred_df = pd.concat(all_predictions, ignore_index=True) if all_predictions else None # Save model (last window) output_dir = Path(args.output) output_dir.mkdir(parents=True, exist_ok=True) model_path = output_dir / f"lgbm_ranker_{MODEL_VERSION}.txt" if best_model is not None: best_model.save_model(str(model_path)) print(f"[output] Model saved: {model_path}") # Upload to HF dataset try: from huggingface_hub import HfApi api = HfApi(token=os.environ.get("HF_TOKEN")) api.upload_file( path_or_fileobj=str(model_path), path_in_repo=f"models/lgbm_ranker_{MODEL_VERSION}.txt", repo_id="cedwyh/jinjing-shared-data", repo_type="dataset", ) print(f"[output] Uploaded: cedwyh/jinjing-shared-data/models/lgbm_ranker_{MODEL_VERSION}.txt") except Exception as e: print(f"[output] WARNING: HF upload failed: {e}") # ── IC comparison: with priors vs without ── if has_priors: print(f"\n{'='*60}") print("PRIOR FACTOR IC COMPARISON (Hold-out / Last Window)") print(f"{'='*60}") # Re-run evaluation on last window's validation data with and without prior cols val_df_last = all_predictions[-1] if all_predictions else None if val_df_last is not None and len(non_prior_feature_cols) > 0: # With priors (already trained) last_val_groups = build_query_groups(val_df_last) y_last = val_df_last[TARGET_COL].values pred_with = val_df_last["pred_rank"].values ic_with = evaluate_rank_ic(y_last, pred_with, last_val_groups) ndcg20_with = evaluate_ndcg(y_last, pred_with, last_val_groups, 20) ndcg50_with = evaluate_ndcg(y_last, pred_with, last_val_groups, 50) # Without priors: train a quick model on non-prior features only print(" Training baseline model (without priors) for comparison...") train_df_last = None # Find train_df for last window for idx, (train_s, train_e, val_s, val_e) in enumerate(WINDOWS): if idx == len(results) - 1: # last trained window train_start_ts = pd.Timestamp(train_s).date() train_end_ts = pd.Timestamp(train_e).date() train_df_last = df.loc[ (df[DATE_COL] >= train_start_ts) & (df[DATE_COL] <= train_end_ts) ].reset_index(drop=True) break if train_df_last is not None and len(train_df_last) > 0: baseline_features = [c for c in non_prior_feature_cols if c in train_df_last.columns] if len(baseline_features) > 0: X_base_train = train_df_last[baseline_features].values.astype(np.float32) y_base_train = train_df_last[TARGET_COL].values base_train_groups = build_query_groups(train_df_last) # Use the same validation set X_base_val = val_df_last[baseline_features].values.astype(np.float32) base_train_data = lgb.Dataset( X_base_train, label=y_base_train, group=base_train_groups, feature_name=baseline_features, ) base_val_data = lgb.Dataset( X_base_val, label=y_last, group=last_val_groups, reference=base_train_data, ) base_model = lgb.train( RANKER_PARAMS, base_train_data, valid_sets=[base_val_data], num_boost_round=NUM_BOOST_ROUND, callbacks=[lgb.early_stopping(EARLY_STOPPING_ROUNDS), lgb.log_evaluation(0)], ) pred_without = base_model.predict(X_base_val) ic_without = evaluate_rank_ic(y_last, pred_without, last_val_groups) ndcg20_without = evaluate_ndcg(y_last, pred_without, last_val_groups, 20) ndcg50_without = evaluate_ndcg(y_last, pred_without, last_val_groups, 50) print(f"\n {'Metric':>12} | {'With Priors':>12} | {'Without':>12} | {'Delta':>12}") print(f" {'-'*12} | {'-'*12} | {'-'*12} | {'-'*12}") print(f" {'NDCG@20':>12} | {ndcg20_with:>12.4f} | {ndcg20_without:>12.4f} | {ndcg20_with - ndcg20_without:>+12.4f}") print(f" {'NDCG@50':>12} | {ndcg50_with:>12.4f} | {ndcg50_without:>12.4f} | {ndcg50_with - ndcg50_without:>+12.4f}") print(f" {'Rank IC':>12} | {ic_with:>12.4f} | {ic_without:>12.4f} | {ic_with - ic_without:>+12.4f}") print(f" {'='*54}") print(f" Prior columns: {prior_cols_in_data}") else: print(" WARNING: No baseline (non-prior) features available for comparison") else: print(" WARNING: Could not locate last training window data") else: print(" WARNING: No validation predictions available for IC comparison") # Upload predictions too if all_pred_df is not None: try: import io buf = io.BytesIO() all_pred_df.to_parquet(buf, index=False) buf.seek(0) api.upload_file( path_or_fileobj=buf, path_in_repo="models/ranker_predictions.parquet", repo_id="cedwyh/jinjing-shared-data", repo_type="dataset", ) print(f"[output] Uploaded predictions to HF dataset") except Exception as e: print(f"[output] WARNING: Predictions upload failed: {e}") else: print("[output] No model trained, nothing saved") # Save predictions locally if all_pred_df is not None: pred_path = output_dir / "ranker_predictions.parquet" all_pred_df.to_parquet(pred_path, index=False) print(f"[output] Predictions saved: {pred_path} ({len(all_pred_df):,} rows)") else: print("[output] No predictions to save") if __name__ == "__main__": main()