#!/usr/bin/env python3 """ jinjing_predict.py — Daily Inference Pipeline for Jinjing V2 Ranking + Meta-Labeling =================================================================================== Pipeline steps: 1. Load trained LightGBM ranker and meta-labeler models 2. Load data (from HuggingFace dataset or local parquet) 3. Walk chronologically through dates: a. Select that date's stocks b. Score with ranker → rank c. Take top 200 candidates d. Apply meta-labeler filter → final signals e. Print per-day JSON summary 4. Print final summary (avg precision, signals/day, coverage) Usage: python jinjing_predict.py \\ --ranker-model /tmp/lgbm_ranker_v1.txt \\ --metalabeler-model /tmp/meta_labeler_v1.txt \\ --data /path/to/daily_data.parquet \\ --output /tmp/jinjing_signals.json Dependencies: pip install lightgbm pandas numpy huggingface_hub """ from __future__ import annotations import argparse import json import logging import os import sys import time from datetime import datetime from typing import Any import numpy as np import pandas as pd logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S", ) logger = logging.getLogger("jinjing_predict") # ────────────────────────────────────────────────────────────────────── # Constants # ────────────────────────────────────────────────────────────────────── HF_REPO = "cedwyh/jinjing-shared-data" TRAINING_DATA_FILE = "ranking_train_data_v1.parquet" # Feature columns used by both ranker and meta-labeler. # These must match the feature set used during training. CONTINUOUS_FEATURES = [ "buy_decay", "sell_decay", "zs_pos", "zs_width", "zs_time", "momentum_div", "volume_div", "slope", "trend_consistency", "regime_prob", "leg_progress", "structure_progress", ] DISCRETE_FEATURES = [ "buy1_count", "buy2_count", "buy3_count", "sell1_count", "sell2_count", "sell3_count", "max_confidence", ] # Trend type is categorical; we one-hot encode it. TREND_TYPES = [ "up", "down", "consolidation", "unknown", ] ALL_FEATURES = CONTINUOUS_FEATURES + DISCRETE_FEATURES + [f"trend_{t}" for t in TREND_TYPES] # Columns expected in the input parquet / dataset. INPUT_COLUMNS = [ "symbol", "date", *CONTINUOUS_FEATURES, *DISCRETE_FEATURES, "trend_type", ] DEFAULT_TOP_K = 200 DEFAULT_FINAL_K = 20 # ────────────────────────────────────────────────────────────────────── # Model loading # ────────────────────────────────────────────────────────────────────── def load_ranker(path: str) -> Any: """Load LightGBM ranker model.""" import lightgbm as lgb if not os.path.isfile(path): raise FileNotFoundError(f"Ranker model not found: {path}") logger.info("Loading ranker model: %s", path) model = lgb.Booster(model_file=path) logger.info(" Ranker loaded — num_trees=%d, num_features=%d", model.num_trees(), model.num_feature()) return model def load_metalabeler(path: str) -> Any: """Load LightGBM meta-labeler model.""" import lightgbm as lgb if not os.path.isfile(path): raise FileNotFoundError(f"Meta-labeler model not found: {path}") logger.info("Loading meta-labeler model: %s", path) model = lgb.Booster(model_file=path) logger.info(" Meta-labeler loaded — num_trees=%d, num_features=%d", model.num_trees(), model.num_feature()) return model # ────────────────────────────────────────────────────────────────────── # Data loading # ────────────────────────────────────────────────────────────────────── def load_data(data_path: str | None = None, use_hf: bool = True) -> pd.DataFrame: """ Load feature data. Priority: 1. Local parquet path (if --data given) 2. HF dataset (default) 3. If neither works, raise. Returns a DataFrame with columns: symbol, date, + features. """ if data_path and os.path.isfile(data_path): logger.info("Loading local parquet: %s", data_path) df = pd.read_parquet(data_path) logger.info(" Loaded %d rows, %d stocks, %d columns", len(df), df["symbol"].nunique() if "symbol" in df.columns else 0, len(df.columns)) return df if use_hf: return _load_from_hf() raise FileNotFoundError( f"No data found at {data_path!r} and HF loading disabled." ) def _load_from_hf() -> pd.DataFrame: """Load training data from HuggingFace dataset repo.""" from huggingface_hub import hf_hub_download logger.info("Downloading %s/%s from HF ...", HF_REPO, TRAINING_DATA_FILE) try: local_path = hf_hub_download( repo_id=HF_REPO, filename=TRAINING_DATA_FILE, repo_type="dataset", ) except Exception as exc: logger.error("HF download failed: %s", exc) raise df = pd.read_parquet(local_path) logger.info(" Loaded %d rows, %d stocks, %d columns", len(df), df["symbol"].nunique() if "symbol" in df.columns else 0, len(df.columns)) return df # ────────────────────────────────────────────────────────────────────── # Feature preparation # ────────────────────────────────────────────────────────────────────── def prepare_features(df: pd.DataFrame) -> pd.DataFrame: """Validate and prepare feature columns for model inference.""" # Fill NaN in all numeric columns for col in df.columns: if col not in {"date", "symbol", "query_group"}: df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0.0) feat_cols = len(df.columns) - 3 # exclude date, symbol, query_group print(f"[INFO] Using {feat_cols} feature columns") return df # ────────────────────────────────────────────────────────────────────── # Daily inference # ────────────────────────────────────────────────────────────────────── def run_daily_inference( ranker: Any, metalabeler: Any, df: pd.DataFrame, top_k: int = DEFAULT_TOP_K, final_k: int = DEFAULT_FINAL_K, ) -> list[dict]: """ Walk through data chronologically by date. For each date: 1. Select rows for that date. 2. Score with ranker. 3. Rank descending by ranker score. 4. Take top_k candidates. 5. Score with meta-labeler on top_k. 6. Apply meta-labeler threshold (≥ 0.5 → signal). 7. Record: top final_k signals + summary stats. Returns a list of per-day result dicts. """ # Ensure date is datetime if not pd.api.types.is_datetime64_any_dtype(df["date"]): df["date"] = pd.to_datetime(df["date"], errors="coerce") # Sort and iterate by date dates = sorted(df["date"].unique()) logger.info("Running daily inference over %d trading days ...", len(dates)) daily_results: list[dict] = [] total_precision_num = 0.0 total_precision_den = 0.0 total_signals = 0 days_with_signals = 0 for i, d in enumerate(dates): day_df = df[df["date"] == d].copy() if day_df.empty: continue n_stocks = len(day_df) # ---- 1. Ranker scores ---- feat_cols = [c for c in day_df.columns if c not in {"date", "symbol", "label_rank", "query_group", "pred_score", "pred_rank", "_meta_label"}] X_rank = day_df[feat_cols].values.astype(np.float64) rank_scores = ranker.predict(X_rank) # ---- 2. Rank ---- day_df["ranker_score"] = rank_scores day_df = day_df.sort_values("ranker_score", ascending=False).reset_index(drop=True) day_df["rank"] = np.arange(len(day_df)) + 1 # ---- 3. Top K candidates ---- candidates = day_df.head(top_k).copy() # ---- 4. Meta-labeler filter ---- X_meta = candidates[feat_cols].values.astype(np.float64) meta_scores = metalabeler.predict(X_meta) candidates["meta_score"] = meta_scores candidates["signal"] = (meta_scores >= 0.5).astype(int) signals = candidates[candidates["signal"] == 1].copy() n_signals = len(signals) n_candidates = len(candidates) # ---- 5. Top K final signals ---- top_signals = signals.head(final_k) if n_signals > 0 else pd.DataFrame() # ---- 6. Build per-day report ---- day_entry = { "date": str(pd.Timestamp(d).date()), "total_stocks": int(n_stocks), "top_k_candidates": int(top_k), "signals_after_meta": int(n_signals), "final_signals": int(min(n_signals, final_k)), "candidates": [], } if not top_signals.empty: for _, row in top_signals.iterrows(): day_entry["candidates"].append({ "symbol": str(row.get("symbol", "")), "ranker_score": round(float(row["ranker_score"]), 6), "meta_score": round(float(row["meta_score"]), 6), "rank": int(row["rank"]), }) daily_results.append(day_entry) # Accumulate summary stats # "Precision" here = fraction of top_k that pass meta-labeler if n_candidates > 0: precision = n_signals / n_candidates else: precision = 0.0 total_precision_num += n_signals total_precision_den += n_candidates if n_signals > 0: total_signals += n_signals days_with_signals += 1 # Print per-day JSON line day_entry_compact = { "date": day_entry["date"], "n_stocks": n_stocks, "top_k": top_k, "signals": n_signals, "final": min(n_signals, final_k), "precision": round(precision, 4), } print(json.dumps(day_entry_compact, ensure_ascii=False)) if (i + 1) % 20 == 0 or i == len(dates) - 1: logger.info(" Progress: %d / %d dates processed", i + 1, len(dates)) # Final summary avg_precision = (total_precision_num / total_precision_den if total_precision_den > 0 else 0.0) summary = { "total_dates": len(dates), "dates_with_signals": days_with_signals, "avg_precision": round(avg_precision, 6), "total_signals": total_signals, "avg_signals_per_day": round(total_signals / len(dates), 2) if dates else 0.0, "signals_per_active_day": round(total_signals / days_with_signals, 2) if days_with_signals > 0 else 0.0, } daily_results.append({"__summary__": summary}) return daily_results # ────────────────────────────────────────────────────────────────────── # CLI # ────────────────────────────────────────────────────────────────────── def parse_args(argv: list[str] | None = None) -> argparse.Namespace: parser = argparse.ArgumentParser( description="Jinjing V2 Daily Inference — Ranking + Meta-Labeling", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: # Use HF training data (development mode) %(prog)s --ranker-model /tmp/lgbm_ranker_v1.txt \\ --metalabeler-model /tmp/meta_labeler_v1.txt # Use local daily parquet %(prog)s --data ./daily_features.parquet \\ --ranker-model /tmp/lgbm_ranker_v1.txt \\ --metalabeler-model /tmp/meta_labeler_v1.txt """, ) parser.add_argument( "--ranker-model", default="/tmp/lgbm_ranker_v1.txt", help="Path to LightGBM ranker model (default: /tmp/lgbm_ranker_v1.txt)", ) parser.add_argument( "--metalabeler-model", default="/tmp/meta_labeler_v1.txt", help="Path to LightGBM meta-labeler model (default: /tmp/meta_labeler_v1.txt)", ) parser.add_argument( "--data", default=None, help="Path to daily data parquet. If omitted, loads from HF dataset.", ) parser.add_argument( "--output", default=None, help="Write full results JSON to this path (optional).", ) parser.add_argument( "--top-k", type=int, default=DEFAULT_TOP_K, help=f"Number of top candidates after ranking (default: {DEFAULT_TOP_K})", ) parser.add_argument( "--final-k", type=int, default=DEFAULT_FINAL_K, help=f"Number of final signals to report per day (default: {DEFAULT_FINAL_K})", ) parser.add_argument( "--no-hf", action="store_true", help="Disable HF dataset loading (only local parquet).", ) parser.add_argument( "--debug", action="store_true", help="Enable debug-level logging.", ) return parser.parse_args(argv) # ────────────────────────────────────────────────────────────────────── # Main # ────────────────────────────────────────────────────────────────────── def main() -> None: args = parse_args() if args.debug: logger.setLevel(logging.DEBUG) start = time.time() # 1. Load models logger.info("=" * 60) logger.info("Jinjing V2 Daily Inference Pipeline") logger.info("=" * 60) ranker = load_ranker(args.ranker_model) metalabeler = load_metalabeler(args.metalabeler_model) # 2. Load data df = load_data(data_path=args.data, use_hf=not args.no_hf) # 3. Prepare features logger.info("Preparing features ...") df = prepare_features(df) # 4. Validate we have required feature columns feat_cols = list(df.columns) if not feat_cols: logger.error("No recognized feature columns found in data!") sys.exit(1) logger.info("Using %d feature columns for inference", len(feat_cols)) # 5. Run daily inference print("") logger.info("Starting daily inference ...") results = run_daily_inference( ranker=ranker, metalabeler=metalabeler, df=df, top_k=args.top_k, final_k=args.final_k, ) # 6. Extract and print summary summary = results[-1].get("__summary__", {}) print("") print("=" * 60) print(" FINAL SUMMARY") print("=" * 60) print(f" Total trading days: {summary.get('total_dates', 'N/A')}") print(f" Days with signals: {summary.get('dates_with_signals', 'N/A')}") print(f" Average precision: {summary.get('avg_precision', 'N/A')}") print(f" Total signals generated: {summary.get('total_signals', 'N/A')}") print(f" Avg signals per day: {summary.get('avg_signals_per_day', 'N/A')}") print(f" Signals per active day: {summary.get('signals_per_active_day', 'N/A')}") print(f" Elapsed: {time.time() - start:.1f}s") print("=" * 60) # 7. Write output JSON if requested if args.output: out_path = args.output logger.info("Writing results to %s", out_path) with open(out_path, "w") as f: json.dump(results, f, ensure_ascii=False, indent=2) print(f" Results saved to: {out_path}") # If models were loaded successfully but no signals, warn if summary.get("total_signals", 0) == 0 and summary.get("total_dates", 0) > 0: logger.warning("No signals generated on any date — check model/data quality.") if __name__ == "__main__": main()