scripts/train_ranker_30f.py

#!/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()