#!/usr/bin/env python3 """train_ranker_30f.py — 30F Fire Eye V8 LGBMRanker 训练 基于 build_data_30f.py 生成的训练数据，5窗 walk-forward 训练 LGBMRanker。 支持多标签 horizon（5d/10d/20d）通过 --horizon 参数切换。 """ import argparse import os, sys, gc, warnings, json, time import numpy as np import pandas as pd import lightgbm as lgb warnings.filterwarnings("ignore") DS = "cedwyh/jinjing-shared-data" N_WINDOWS = 5 VAL_SPLIT = 0.3 LGB_PARAMS = { "objective": "lambdarank", "boosting_type": "gbdt", "metric": "ndcg", "ndcg_eval_at": [20, 50], "num_leaves": 63, "learning_rate": 0.05, "feature_fraction": 0.6, # 0.6: reduced from 0.8 — diverse feature usage (P2) "bagging_fraction": 0.8, "bagging_freq": 5, "lambda_l1": 0.1, # L1 regularization (P2) "lambda_l2": 1.0, # L2 regularization — prevent single-feature dominance (P2) "min_data_in_leaf": 50, "num_threads": 32, "verbosity": -1, "seed": 42, } NUM_BOOST_ROUND = 300 EARLY_STOPPING_ROUNDS = 50 from huggingface_hub import hf_hub_download, HfApi api = HfApi() def main(): parser = argparse.ArgumentParser(description="30F Fire Eye V8 Ranker Training") parser.add_argument("--horizon", type=int, default=20, choices=[5, 10, 20], help="Prediction horizon in trading days (default: 20)") args = parser.parse_args() HORIZON = args.horizon LABEL_COL = f"label_rank_{HORIZON}d" t0 = time.time() print("=" * 60) print(f"30F Fire Eye V8 — LGBMRanker Training (A0=30min, H={HORIZON}d)") print("=" * 60) print() # ── Step 1: Load training data ── print("[1/5] Loading training data...") data_path = hf_hub_download(repo_id=DS, filename="ranking_train_30f_v1.parquet", repo_type="dataset") df = pd.read_parquet(data_path) print(f" Loaded: {len(df):,} rows x {len(df.columns)} cols") print(f" Unique dates: {df['date'].nunique()}") print(f" Unique symbols: {df['symbol'].nunique()}") # Verify label column exists if LABEL_COL not in df.columns: print(f" ❌ Label column '{LABEL_COL}' not found in training data!") print(f" Available label columns: {[c for c in df.columns if c.startswith('label_rank_')]}") sys.exit(1) # ── Step 2: Identify columns ── print("[2/5] Identifying feature columns...") # Exclude all ID cols, all label cols, and intermediate forward return cols id_cols = {"date", "symbol", "query_group", "close"} # Also exclude ALL label_rank variants and forward_ret columns exclude_patterns = {"label_rank", "forward_", "label_rank_20d", "label_rank_10d", "label_rank_5d"} feature_cols = [c for c in df.columns if c not in id_cols and not any(c.startswith(p) for p in exclude_patterns)] print(f" Features: {len(feature_cols)}") # Verify label print(f" Label column: {LABEL_COL}") print(f" Label distribution:") for k, v in sorted(df[LABEL_COL].value_counts().items()): print(f" Decile {int(k):2d}: {v:>8,}") # Ensure query_group is sequential df = df.sort_values(["query_group", "symbol"]).reset_index(drop=True) # Sort by date for walk-forward unique_dates = sorted(df["date"].unique()) print(f" Date range: {unique_dates[0]} → {unique_dates[-1]} ({len(unique_dates)} days)") # ── Step 3: Walk-forward windows ── print("[3/5] Creating walk-forward windows...") chunk_size = len(unique_dates) // N_WINDOWS windows = [] for w in range(N_WINDOWS): val_end = (w + 1) * chunk_size val_start = val_end - int(chunk_size * VAL_SPLIT) if w == N_WINDOWS - 1: val_end = len(unique_dates) val_start = max(val_end - int(chunk_size * VAL_SPLIT), 0) val_dates = set(unique_dates[max(0, val_start):val_end]) train_dates = set(unique_dates[:max(0, val_start)]) if not train_dates or len(train_dates) < 20: train_dates = set(unique_dates[:max(0, val_end - chunk_size)]) val_dates = set(unique_dates[max(0, val_end - chunk_size):val_end]) windows.append((train_dates, val_dates, w + 1)) # ── Step 4: Train ── print("[4/5] Training...") results = [] models_dir = f"/tmp/v10_ranker_30f_h{HORIZON}d" os.makedirs(models_dir, exist_ok=True) for train_dates, val_dates, w_idx in windows: print(f"\n{'='*60}") print(f"Window {w_idx}/{N_WINDOWS}") print(f" Train: {min(train_dates)} → {max(train_dates)} ({len(train_dates)} days)") print(f" Val: {min(val_dates)} → {max(val_dates)} ({len(val_dates)} days)") train_mask = df["date"].isin(train_dates) val_mask = df["date"].isin(val_dates) X_train = df.loc[train_mask, feature_cols].values y_train = df.loc[train_mask, LABEL_COL].values q_train = df.loc[train_mask, "query_group"].values X_val = df.loc[val_mask, feature_cols].values y_val = df.loc[val_mask, LABEL_COL].values q_val = df.loc[val_mask, "query_group"].values print(f" Train: {len(X_train):,} rows, {q_train.max()-q_train.min()+1} groups") print(f" Val: {len(X_val):,} rows, {q_val.max()-q_val.min()+1} groups") train_data = lgb.Dataset(X_train, label=y_train, feature_name=feature_cols, group=np.bincount(q_train).tolist()) val_data = lgb.Dataset(X_val, label=y_val, feature_name=feature_cols, group=np.bincount(q_val).tolist(), reference=train_data) gbm = lgb.train( LGB_PARAMS, train_data, valid_sets=[val_data], num_boost_round=NUM_BOOST_ROUND, callbacks=[lgb.early_stopping(EARLY_STOPPING_ROUNDS), lgb.log_evaluation(50)], feval=None, ) # Evaluate y_pred = gbm.predict(X_val) val_df = df.loc[val_mask].copy() val_df["pred_score"] = y_pred # Rank IC per day rank_ics = [] for d in val_dates: day = val_df[val_df["date"] == d] if len(day) < 10: continue ic = day["pred_score"].rank().corr(day[LABEL_COL].rank()) if not np.isnan(ic): rank_ics.append(ic) ndcg20 = gbm.best_score["valid_0"]["ndcg@20"] ndcg50 = gbm.best_score["valid_0"].get("ndcg@50", ndcg20) avg_rank_ic = np.mean(rank_ics) if rank_ics else 0 results.append({ "window": w_idx, "ndcg@20": round(ndcg20, 4), "ndcg@50": round(ndcg50, 4), "rank_ic": round(avg_rank_ic, 4), "best_iter": gbm.best_iteration, "train_rows": len(X_train), "val_rows": len(X_val), }) print(f" ✅ NDCG@20={ndcg20:.4f}, NDCG@50={ndcg50:.4f}, Rank IC={avg_rank_ic:.4f}") # Save window model model_path = f"{models_dir}/v10_30f_w{w_idx}_h{HORIZON}d.txt" gbm.save_model(model_path) print(f" Model saved: {model_path}") del X_train, y_train, q_train, X_val, y_val, q_val, train_data, val_data, gbm gc.collect() # ── Step 5: Summary ── print(f"\n{'='*60}") print(f"SUMMARY — H={HORIZON}d") print(f"{'='*60}") print(f"{'Window':>6} | {'NDCG@20':>8} | {'NDCG@50':>8} | {'Rank IC':>8} | Best Iter | Train Rows | Val Rows") print(f"{'-'*6}-+-{'-'*8}-+-{'-'*8}-+-{'-'*8}-+-{'-'*9}-+-{'-'*10}-+-{'-'*8}") avg_ndcg20, avg_ndcg50, avg_ic = 0, 0, 0 for r in results: print(f" {r['window']} | {r['ndcg@20']:.4f} | {r['ndcg@50']:.4f} | {r['rank_ic']:.4f} | {r['best_iter']:3d} | {r['train_rows']:>9,} | {r['val_rows']:>7,}") avg_ndcg20 += r['ndcg@20'] avg_ndcg50 += r['ndcg@50'] avg_ic += r['rank_ic'] n = len(results) print(f"{'AVG':>6} | {avg_ndcg20/n:.4f} | {avg_ndcg50/n:.4f} | {avg_ic/n:.4f}") # ── Save ensemble model ── print(f"\n[5/5] Saving artifacts to HF...") # Upload individual window models for r in results: w = r['window'] local_path = f"{models_dir}/v10_30f_w{w}_h{HORIZON}d.txt" hf_path = f"models/v10_30f_w{w}_h{HORIZON}d.txt" api.upload_file(path_or_fileobj=local_path, path_in_repo=hf_path, repo_id=DS, repo_type="dataset") print(f" Uploaded: {hf_path}") # Save and upload results JSON results_json = { "model": "30f_fire_eye_v8", "horizon": HORIZON, "features": len(feature_cols), "feature_cols": feature_cols, "params": LGB_PARAMS, "windows": results, "date_range": [unique_dates[0], unique_dates[-1]], "elapsed_seconds": time.time() - t0, } json_path = "/tmp/training_results_30f.json" with open(json_path, "w") as f: json.dump(results_json, f, indent=2, default=str) hf_json_path = f"models/training_results_30f_h{HORIZON}d.json" api.upload_file(path_or_fileobj=json_path, path_in_repo=hf_json_path, repo_id=DS, repo_type="dataset") print(f" Uploaded: {hf_json_path}") total_time = time.time() - t0 print(f"\n Total time: {total_time:.0f}s ({total_time/60:.1f}min)") print("Done.") if __name__ == "__main__": main()