#!/usr/bin/env python3 """ train_metalabeler.py — Binary Meta-Labeler for Jinjing (金睛) V2 v1.0 Trains a binary LightGBM classifier on top of ranking model candidates. Reads ranking data from HF Hub, simulates a Top-K candidate selection using noisy ranking scores, and trains a meta-labeler that filters false positives from the ranker's Top-200 list. Usage: export HF_TOKEN=hf_... python train_metalabeler.py [--top-k 200] [--cv-folds 5] [--output /tmp/meta_labeler_v1.txt] Output: - /tmp/meta_labeler_v1.txt (LightGBM Booster text dump) - Console: AUC, Precision@K, best threshold, confusion matrix """ from __future__ import annotations import argparse import os import sys import warnings from pathlib import Path import numpy as np import pandas as pd from huggingface_hub import hf_hub_download from sklearn.metrics import ( auc as sk_auc, confusion_matrix, precision_score, roc_auc_score, roc_curve, ) from sklearn.model_selection import StratifiedKFold # --------------------------------------------------------------------------- # LightGBM may trigger many informational messages; keep output clean. # --------------------------------------------------------------------------- warnings.filterwarnings("ignore", category=UserWarning, module="lightgbm") try: import lightgbm as lgb except ImportError as exc: print(f"[FATAL] lightgbm is required — install with: pip install lightgbm") sys.exit(1) # =========================================================================== # Constants / defaults # =========================================================================== HF_REPO = "cedwyh/jinjing-shared-data" HF_FILE = "ranking_train_data_v1.parquet" DEFAULT_TOP_K = 200 # candidates per date DEFAULT_CV_FOLDS = 5 DEFAULT_LABEL_THRESH_HIGH = 8 # rank >= 8 => good performer (label=1) DEFAULT_LABEL_THRESH_LOW = 3 # rank <= 3 => bad performer (label=0) DEFAULT_OUTPUT = "/tmp/meta_labeler_v1.txt" RANDOM_STATE = 42 # =========================================================================== # 1. Load data # =========================================================================== def load_data(hf_token: str | None = None) -> pd.DataFrame: """Download and load the ranking parquet from Hugging Face Hub.""" print("[1/6] Loading data from Hugging Face Hub …", flush=True) local_path = hf_hub_download( repo_id=HF_REPO, filename=HF_FILE, repo_type="dataset", token=hf_token, ) df = pd.read_parquet(local_path) print(f" Loaded {len(df):,} rows × {len(df.columns)} cols", flush=True) return df # =========================================================================== # 2. Simulate ranking and build meta-labeler training set # =========================================================================== def build_meta_dataset( df: pd.DataFrame, top_k: int = DEFAULT_TOP_K, thr_high: int = DEFAULT_LABEL_THRESH_HIGH, thr_low: int = DEFAULT_LABEL_THRESH_LOW, noise_scale: float = 0.8, rng_seed: int = RANDOM_STATE, ) -> pd.DataFrame: """ Simulate a ranker's predicted scores and build a binary meta-label training set. Strategy -------- - `label_rank` (1-10) is the ground-truth decile rank. - We simulate *predicted scores* as ``label_rank + N(0, noise_scale)`` so the meta-labeler sees realistic imperfect rankings. - Within each date, the top-*top_k* stocks by simulated score are kept as *candidates*. - A candidate gets meta-label = 1 if its true rank >= thr_high (good), 0 if its true rank <= thr_low (bad). Middle ranks are discarded. """ rng = np.random.default_rng(rng_seed) print("[2/6] Simulating ranking scores …", flush=True) # --- identify date columns (prefer 'date', fall back to first col) ---- date_col = "date" if "date" in df.columns else df.columns[0] rank_col = "label_rank" if "label_rank" in df.columns else None if rank_col is None: print("[FATAL] Column 'label_rank' not found in dataset.", flush=True) sys.exit(1) df = df.copy() # Simulated predicted score = true rank + Gaussian noise df["_pred_score"] = df[rank_col] + rng.normal(0, noise_scale, size=len(df)) # Group by date, keep top-K by predicted score print(f" Selecting top-{top_k} candidates per date …", flush=True) candidates = ( df.groupby(date_col, group_keys=False) .apply(lambda g: g.nlargest(top_k, "_pred_score"), include_groups=False) .reset_index(drop=True) ) # Create binary meta-label candidates["_meta_label"] = np.nan candidates.loc[candidates[rank_col] >= thr_high, "_meta_label"] = 1 candidates.loc[candidates[rank_col] <= thr_low, "_meta_label"] = 0 before = len(candidates) candidates = candidates.dropna(subset=["_meta_label"]).reset_index(drop=True) candidates["_meta_label"] = candidates["_meta_label"].astype(int) print( f" Discarded middle ranks ({thr_low+1}–{thr_high-1}): " f"{before - len(candidates)} rows removed.", flush=True, ) print(f" Meta-label training set: {len(candidates):,} rows", flush=True) # Class balance pos = (candidates["_meta_label"] == 1).sum() neg = (candidates["_meta_label"] == 0).sum() print(f" Positives (label=1, rank≥{thr_high}): {pos:,} " f"Negatives (label=0, rank≤{thr_low}): {neg:,} " f"Ratio: {pos/neg:.3f}", flush=True) return candidates # =========================================================================== # 3. Feature engineering # =========================================================================== def get_feature_columns(df: pd.DataFrame) -> list[str]: """Identify feature columns (exclude metadata / label columns).""" exclude = { "date", "stock_id", "symbol", "ticker", "ts_code", "label_rank", "_pred_score", "_meta_label", "index", } return [c for c in df.columns if c.lower() not in exclude] def prepare_xy( df: pd.DataFrame, feature_cols: list[str] | None = None, ) -> tuple[pd.DataFrame, pd.Series, np.ndarray | None]: """Extract feature matrix X, target y, and optional sample weights.""" if feature_cols is None: feature_cols = get_feature_columns(df) X = df[feature_cols].copy() y = df["_meta_label"].values # Basic sanity assert X.shape[1] > 0, "No feature columns found!" assert y.ndim == 1 # Handle any remaining NaN in features nan_count = X.isna().sum().sum() if nan_count > 0: print(f" Warning: {nan_count} NaN values in features — filling with 0.", flush=True) X = X.fillna(0) return X, y, None # =========================================================================== # 4. Train with cross-validation # =========================================================================== def train_cv( X: pd.DataFrame, y: np.ndarray, n_folds: int = DEFAULT_CV_FOLDS, random_state: int = RANDOM_STATE, ) -> tuple[lgb.Booster, float, float]: """ 5-fold stratified cross-validation with early stopping. Parameters ---------- X, y : training data n_folds : number of CV folds (default 5) Returns ------- (trained_booster, mean_val_auc, oof_auc) """ print(f"[3/6] Training LightGBM with {n_folds}-fold CV …", flush=True) skf = StratifiedKFold( n_splits=n_folds, shuffle=True, random_state=random_state ) params = { "objective": "binary", "metric": "auc", "boosting_type": "gbdt", "num_leaves": 63, "learning_rate": 0.05, "feature_fraction": 0.8, "bagging_fraction": 0.8, "bagging_freq": 5, "verbose": -1, "seed": random_state, "first_metric_only": True, } fold_models: list[lgb.Booster] = [] fold_aucs: list[float] = [] oof_preds = np.zeros(len(y), dtype=np.float64) for fold, (train_idx, val_idx) in enumerate(skf.split(X, y)): X_tr, X_val = X.iloc[train_idx], X.iloc[val_idx] y_tr, y_val = y[train_idx], y[val_idx] train_data = lgb.Dataset(X_tr, label=y_tr) val_data = lgb.Dataset(X_val, label=y_val, reference=train_data) model = lgb.train( params=params, train_set=train_data, valid_sets=[val_data], valid_names=["valid"], callbacks=[ lgb.early_stopping(stopping_rounds=50, verbose=False), lgb.log_evaluation(period=0), ], num_boost_round=2000, ) fold_pred = model.predict(X_val, num_iteration=model.best_iteration) fold_auc = roc_auc_score(y_val, fold_pred) oof_preds[val_idx] = fold_pred fold_models.append(model) fold_aucs.append(fold_auc) print(f" Fold {fold + 1}/{n_folds} — AUC = {fold_auc:.5f}", flush=True) mean_val_auc = float(np.mean(fold_aucs)) oof_auc = roc_auc_score(y, oof_preds) print(f" Mean CV AUC = {mean_val_auc:.5f}", flush=True) print(f" Out-of-fold AUC = {oof_auc:.5f}", flush=True) # Retrain on full data using best iteration from CV average print(" Retraining on full dataset …", flush=True) full_data = lgb.Dataset(X, label=y) # Use the median number of boosting rounds from the folds best_rounds = int(np.median([m.best_iteration for m in fold_models])) final_model = lgb.train( params=params, train_set=full_data, num_boost_round=best_rounds, valid_sets=[full_data], valid_names=["train"], callbacks=[lgb.log_evaluation(period=0)], ) return final_model, oof_auc, oof_preds # =========================================================================== # 5. Evaluation # =========================================================================== def evaluate( y_true: np.ndarray, y_pred: np.ndarray, thresholds: list[float] | None = None, ) -> tuple[float, list[tuple[int, float, float]]]: """ Evaluate binary classifier. Returns ------- (best_threshold, precision_at_k_list) where precision_at_k_list = [(K, precision, threshold_for_K), ...] """ print("[4/6] Evaluating on out-of-fold predictions …", flush=True) auc = roc_auc_score(y_true, y_pred) fpr, tpr, roc_thresholds = roc_curve(y_true, y_pred) # Youden index -> best threshold youden = tpr - fpr best_idx = int(np.argmax(youden)) best_thr = float(roc_thresholds[best_idx]) print(f" AUC = {auc:.5f}", flush=True) print(f" Best threshold = {best_thr:.5f} (Youden index)", flush=True) # --- Precision@K --- # Rank by predicted probability descending order = np.argsort(y_pred)[::-1] y_sorted = y_true[order] precisions: list[tuple[int, float, float]] = [] for k in (10, 20, 50): prec_k = float(precision_score(y_sorted[:k], np.ones(k), zero_division=0.0)) precisions.append((k, prec_k, best_thr)) print(f" Precision@{k:<3d} = {prec_k:.5f}", flush=True) # --- Confusion matrix --- y_pred_bin = (y_pred >= best_thr).astype(int) tn, fp, fn, tp = confusion_matrix(y_true, y_pred_bin).ravel() print(f"\n Confusion Matrix @ threshold = {best_thr:.5f}", flush=True) print(f" Pred Neg Pred Pos", flush=True) print(f" Actual Neg {tn:>8d} {fp:>8d}", flush=True) print(f" Actual Pos {fn:>8d} {tp:>8d}", flush=True) total = tn + fp + fn + tp acc = (tn + tp) / total prec = tp / (tp + fp) if (tp + fp) > 0 else 0.0 rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0 f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0 print(f" Accuracy = {acc:.5f}", flush=True) print(f" Precision = {prec:.5f}", flush=True) print(f" Recall = {rec:.5f}", flush=True) print(f" F1 = {f1:.5f}", flush=True) return best_thr, precisions # =========================================================================== # 6. Save model # =========================================================================== def save_model(model: lgb.Booster, path: str) -> None: """Save LightGBM booster in text format and upload to HF dataset.""" import shutil # Always save to /tmp first (writable) tmp_path = "/tmp/meta_labeler_v1.txt" model.save_model(tmp_path) print(f" Model saved to {tmp_path}") # Copy to requested output path if different if path and path != tmp_path: try: shutil.copy(tmp_path, path) print(f" Copied to {path}") except Exception as e: print(f" WARNING: Could not copy to {path}: {e}") # Upload to HF dataset try: from huggingface_hub import HfApi api = HfApi(token=os.environ.get("HF_TOKEN")) api.upload_file( path_or_fileobj=tmp_path, path_in_repo="models/meta_labeler_v1.txt", repo_id="cedwyh/jinjing-shared-data", repo_type="dataset", ) print(f" Uploaded: cedwyh/jinjing-shared-data/models/meta_labeler_v1.txt") except Exception as e: print(f" WARNING: HF upload failed: {e}") print(f" Model saved ({os.path.getsize(tmp_path)/1024:.1f} KB).", flush=True) # =========================================================================== # 7. Summary # =========================================================================== def print_summary( auc: float, precisions: list[tuple[int, float, float]], best_thr: float, ) -> None: """Final summary table.""" print(f"[6/6] Final Summary", flush=True) print("=" * 52, flush=True) print(f" {'Metric':<22s} {'Value':>10s}", flush=True) print("-" * 52, flush=True) print(f" {'AUC':<22s} {auc:>10.5f}", flush=True) for k, p, _ in precisions: print(f" {'Precision@' + str(k):<22s} {p:>10.5f}", flush=True) print(f" {'Best threshold':<22s} {best_thr:>10.5f}", flush=True) print("=" * 52, flush=True) # =========================================================================== # CLI # =========================================================================== def parse_args(argv: list[str] | None = None) -> argparse.Namespace: parser = argparse.ArgumentParser( description="Train a binary meta-labeler for Jinjing V2.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "--top-k", type=int, default=DEFAULT_TOP_K, help="Number of top candidates per date to keep.", ) parser.add_argument( "--cv-folds", type=int, default=DEFAULT_CV_FOLDS, help="Number of cross-validation folds.", ) parser.add_argument( "--output", type=str, default=DEFAULT_OUTPUT, help="Path to save the trained LightGBM model (text format).", ) parser.add_argument( "--noise-scale", type=float, default=0.8, help="Standard deviation of Gaussian noise added to label_rank " "for simulated predictions.", ) parser.add_argument( "--high-threshold", type=int, default=DEFAULT_LABEL_THRESH_HIGH, help="label_rank >= this value => positive class.", ) parser.add_argument( "--low-threshold", type=int, default=DEFAULT_LABEL_THRESH_LOW, help="label_rank <= this value => negative class.", ) parser.add_argument( "--hf-token", type=str, default=None, help="Hugging Face token (default: $HF_TOKEN).", ) return parser.parse_args(argv) # =========================================================================== # Main # =========================================================================== def main() -> None: args = parse_args() hf_token = args.hf_token or os.environ.get("HF_TOKEN") if not hf_token: print( "[FATAL] HF_TOKEN not set. Provide via --hf-token or " "the HF_TOKEN environment variable.", flush=True, ) sys.exit(1) # ---- 1. Load ---- df = load_data(hf_token) # ---- 2. Build meta dataset ---- meta_df = build_meta_dataset( df, top_k=args.top_k, thr_high=args.high_threshold, thr_low=args.low_threshold, noise_scale=args.noise_scale, ) # ---- 3. Features ---- feat_cols = get_feature_columns(meta_df) print(f" Using {len(feat_cols)} feature columns.", flush=True) X, y, _ = prepare_xy(meta_df, feat_cols) # ---- 4. Train ---- model, oof_auc, oof_preds = train_cv(X, y, n_folds=args.cv_folds) # ---- 5. Evaluate ---- best_thr, precisions = evaluate(y, oof_preds) # ---- 6. Save ---- save_model(model, args.output) # ---- 7. Summary ---- print_summary(oof_auc, precisions, best_thr) if __name__ == "__main__": main()