scripts/jinjing_predict.py

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