scripts/build_data.py

#!/usr/bin/env python3
"""
build_ranking_data.py — Jinjing V2 Ranking Training Data Construction

Builds a training matrix for LGBMRanker (lambdarank) by:
  1. Loading chan_engine_features + all_features_v2 from HuggingFace dataset
  2. Merging on (date, symbol)
  3. Adding 4 cross-sectional rank features per date
  4. Computing PRISM-VQ prior_* factor columns (13 classic cross-sectional priors)
  5. Creating ranking label (forward_20d_ret decile 1-10)
  6. Adding query_group column (sequential group ID per date)
  7. Dropping rows with any NaN in feature columns
  8. Saving to parquet

Usage:
  python build_ranking_data.py --output /tmp/ranking_train_data.parquet
  python build_ranking_data.py --output /tmp/ranking_train_data.parquet --sample 1000

Environment:
  HF_TOKEN: HuggingFace token for dataset access
"""

import argparse
import os
import sys
import warnings
from datetime import datetime

import numpy as np
import pandas as pd

warnings.filterwarnings("ignore")

# ── PRISM-VQ prior factors (optional) ──
try:
    from factor_priors import compute_all_priors, PRIOR_COLUMNS
except ImportError:
    compute_all_priors = None
    PRIOR_COLUMNS = []

# ---------------------------------------------------------------------------
# Column definitions
# ---------------------------------------------------------------------------

CHAN_FEATURE_COLS = [
    "buy1", "buy2", "buy3", "sell1", "sell2", "sell3",
    "bi_strength", "zhongshu_amplitude", "dist_last_buy", "bi_zhongshu_count",
]

# V5 proxy features in V2 parquet (actual names, not f1_ prefix)
V5_FEATURE_COLS = [
    "buy_decay", "sell_decay", "zs_pos", "zs_width", "zs_time",
    "momentum_div", "volume_div", "slope", "trend_consistency",
    "regime_prob", "leg_progress", "structure_progress",
]

# Selected quant + technical features that exist in V2 parquet
V2_QUANT_FEATURE_COLS = [
    "ret_1d", "ret_5d", "ret_10d", "ret_20d", "ret_30d", "ret_60d",
    "ma_5", "ma_20", "ma_60",
    "volatility_10d", "volatility_20d",
    "vol_ma5", "vol_ma20",
    "rsi_12", "rsi_24",
    "macd_hist",
    "atr_14",
    "close_pos_20d", "close_pos_60d",
    "vol_ratio_5", "vol_ratio_20",
]

RANK_FEATURE_COLS = [
    "rank_bi_strength", "rank_zhongshu", "rank_momentum", "rank_volume",
]

ID_COLS = ["date", "symbol"]

LABEL_COL = "label_rank"

ALL_FEATURE_COLS = (
    CHAN_FEATURE_COLS + V5_FEATURE_COLS + V2_QUANT_FEATURE_COLS + RANK_FEATURE_COLS
)

OUTPUT_COLS = ID_COLS + ["query_group"] + ALL_FEATURE_COLS + [LABEL_COL]


def load_hf_parquet(dataset_name: str, file_name: str, token: str | None = None) -> pd.DataFrame:
    """Load a parquet file from a HuggingFace dataset using hf_hub_download."""
    try:
        from huggingface_hub import hf_hub_download
        path = hf_hub_download(repo_id=dataset_name, filename=file_name, repo_type="dataset")
        return pd.read_parquet(path)
    except Exception:
        import io, urllib.request
        url = f"https://huggingface.co/datasets/{dataset_name}/resolve/main/{file_name}?download=1"
        if token:
            headers = {"Authorization": f"Bearer {token}"}
        else:
            headers = {}
        req = urllib.request.Request(url, headers=headers)
        with urllib.request.urlopen(req, timeout=300) as resp:
            data = resp.read()
        return pd.read_parquet(io.BytesIO(data))


def try_load_sample(path: str) -> pd.DataFrame | None:
    """Try loading a local sample parquet file (for dev/testing)."""
    if os.path.exists(path):
        print(f"  Loading sample from {path}")
        return pd.read_parquet(path)
    return None


def rank_percentile(series: pd.Series) -> pd.Series:
    """Compute within-group percentile rank (0-1)."""
    ranks = series.rank(method="average", ascending=True)
    return (ranks - 1) / max(ranks.max() - 1, 1)


def compute_forward_return(
    df: pd.DataFrame, price_col: str = "close", period: int = 20
) -> pd.DataFrame:
    """
    Compute forward_{period}d_ret for each symbol.
    Uses price_col; if not found, looks for 'close' or raises.
    """
    if price_col not in df.columns:
        candidates = [c for c in df.columns if "close" in c.lower()]
        if candidates:
            price_col = candidates[0]
        else:
            raise KeyError(
                f"Price column '{price_col}' not found in V2 features and no close-like column available. "
                "Cannot compute forward returns."
            )

    df = df.copy()
    df = df.sort_values(["symbol", "date"])
    df[f"forward_{period}d_ret"] = (
        df.groupby("symbol")[price_col].shift(-period) / df[price_col] - 1
    )
    return df


def main():
    parser = argparse.ArgumentParser(
        description="Jinjing V2 Ranking Training Data Construction"
    )
    parser.add_argument(
        "--output",
        type=str,
        default="/tmp/ranking_train_data.parquet",
        help="Output parquet path (default: /tmp/ranking_train_data.parquet)",
    )
    parser.add_argument(
        "--sample",
        type=int,
        default=None,
        help="Sample N rows for testing (default: use all data)",
    )
    parser.add_argument(
        "--dataset",
        type=str,
        default="cedwyh/jinjing-shared-data",
        help="HuggingFace dataset name (default: cedwyh/jinjing-shared-data)",
    )
    parser.add_argument(
        "--use-priors",
        action=argparse.BooleanOptionalAction,
        default=True,
        help="Compute PRISM-VQ prior_* feature columns (default: True). Requires OHLCV columns.",
    )
    args = parser.parse_args()

    hf_token = os.environ.get("HF_TOKEN")
    if not hf_token:
        print("[WARN] HF_TOKEN not set. Trying without token (public dataset)...")
    print("=" * 60)
    print("Jinjing V2 — Ranking Training Data Builder")
    print("=" * 60)
    print(f"Output: {args.output}")
    if args.sample:
        print(f"Sample mode: {args.sample} rows")
    print()

    # -----------------------------------------------------------------------
    # Step 1: Load data
    # -----------------------------------------------------------------------
    print("[1/7] Loading data...")

    # Try local samples first (dev environment)
    df_chan = try_load_sample("/tmp/chan_sample.parquet")
    if df_chan is None:
        print("  Loading chan_engine_features.parquet from HuggingFace...")
        df_chan = load_hf_parquet(
            args.dataset, "chan_engine_features.parquet", hf_token
        )

    df_v2 = try_load_sample("/tmp/v2_sample.parquet")
    if df_v2 is None:
        print("  Loading all_features_v2.parquet from HuggingFace...")
        df_v2 = load_hf_parquet(args.dataset, "all_features_v2.parquet", hf_token)

    print(f"  chan_engine_features: {df_chan.shape[0]:,} rows x {df_chan.shape[1]} cols")
    print(f"  all_features_v2:      {df_v2.shape[0]:,} rows x {df_v2.shape[1]} cols")
    print()

    # -----------------------------------------------------------------------
    # Step 2: Merge on (date, symbol)
    # -----------------------------------------------------------------------
    print("[2/7] Merging chan + V2 features on (date, symbol)...")

    # ── Date type defense layer 1: normalize all sources to string YYYY-MM-DD ──
    for name, d in [("chan", df_chan), ("v2", df_v2)]:
        if "date" in d.columns:
            before = str(d["date"].dtype)
            # Use format='mixed' to handle YYYY-MM-DD, 20100104, 2010-01-04 00:00:00 etc.
            d["date"] = pd.to_datetime(
                d["date"], format="mixed", errors="coerce"
            ).dt.strftime("%Y-%m-%d")
            n_null = d["date"].isna().sum()
            if n_null > 0:
                print(
                    f"  ⚠️ {name}: {n_null} date values still failed to parse"
                    f" (sampling NaNs: {d.loc[d['date'].isna(), 'date'].head(3).tolist()})"
                )
                # Fallback 1: brute-force truncation for any that coerce failed
                d["date"] = d["date"].fillna(
                    d["date"].astype(str).str[:10]
                )
            n_null2 = d["date"].isna().sum()
            print(f"  {name}: {before} → {d['date'].dtype} (nulls={n_null}→{n_null2})")

    # Ensure symbol columns are string
    for d in [df_chan, df_v2]:
        if "symbol" in d.columns:
            d["symbol"] = d["symbol"].astype(str)

    # Determine which V2 columns to keep
    # We keep: V2_QUANT_FEATURE_COLS + V5 features
    # plus any label/price columns needed later
    v2_keep_cols = list(
        set(
            ID_COLS
            + V2_QUANT_FEATURE_COLS
            + V5_FEATURE_COLS
            + ["ret_5d"]  # ensure we have at least one ret col as fallback label
        )
    )
    # Also check what label columns exist
    existing_label_cols = [
        c
        for c in df_v2.columns
        if "forward" in c.lower()
        or "label" in c.lower()
        or "ret_" in c.lower()
        or "return" in c.lower()
    ]
    # Keep any label columns found
    for c in existing_label_cols:
        if c not in v2_keep_cols:
            v2_keep_cols.append(c)
    # Also keep price columns for forward return computation
    price_candidates = [
        c for c in df_v2.columns if "close" in c.lower() or "price" in c.lower()
    ]
    for c in price_candidates:
        if c not in v2_keep_cols:
            v2_keep_cols.append(c)

    # When priors are enabled, also keep raw OHLCV columns for factor computation
    if args.use_priors:
        ohlcv_raw = ["open", "high", "low", "volume"]
        for c in ohlcv_raw:
            if c in df_v2.columns and c not in v2_keep_cols:
                v2_keep_cols.append(c)

    # Filter to columns that actually exist
    v2_keep_cols = [c for c in v2_keep_cols if c in df_v2.columns]

    df_v2_sub = df_v2[v2_keep_cols].copy()

    df = pd.merge(df_chan, df_v2_sub, on=["date", "symbol"], how="inner")
    print(f"  Merged shape: {df.shape[0]:,} rows x {df.shape[1]} cols")

    # ── Fix BUG 1: reconcile _x/_y suffix from overlapping columns ──
    # Both engine and V2 parquets share V5 features; merge renames them.
    # Keep engine version (_x from left=df_chan), drop V2 version (_y).
    x_cols = [c for c in df.columns if c.endswith("_x")]
    y_cols = [c for c in df.columns if c.endswith("_y")]
    if x_cols:
        for xc in x_cols:
            base = xc[:-2]
            df[base] = df[xc]
        df = df.drop(columns=x_cols + y_cols)
        print(f"  Reconciled {len(x_cols)} overlapping columns ({[c[:-2] for c in x_cols]})")
    del x_cols, y_cols

    # ── Merge validation defense layer 2: sanity-check the output ──
    n_dates = df["date"].nunique()
    n_syms = df["symbol"].nunique()
    print(f"  Unique dates:  {n_dates}")
    print(f"  Unique symbols: {n_syms}")
    print(f"  Date range:    {df['date'].min()} → {df['date'].max()}")
    if n_dates < 200:
        print(
            "  ❌ RED LINE: only {n_dates} unique dates — merge likely silently"
            " dropped most rows due to date type mismatch!"
        )
        sys.exit(1)

    # ── Early sample: apply BEFORE Step 3 & 4 so prior computation is fast ──
    if args.sample and args.sample < len(df):
        df = df.sample(n=args.sample, random_state=42).reset_index(drop=True)
        print(f"  Early sample (reduced to {len(df):,} rows)")
    print()

    # -----------------------------------------------------------------------
    # Step 3: Add cross-sectional rank features per date
    # -----------------------------------------------------------------------
    print("[3/7] Adding cross-sectional rank features...")

    # rank_bi_strength
    if "bi_strength" in df.columns:
        df["rank_bi_strength"] = df.groupby("date")["bi_strength"].transform(
            rank_percentile
        )
    else:
        print("  WARNING: bi_strength not found, rank_bi_strength set to NaN")
        df["rank_bi_strength"] = np.nan

    # rank_zhongshu
    if "zhongshu_amplitude" in df.columns:
        df["rank_zhongshu"] = df.groupby("date")["zhongshu_amplitude"].transform(
            rank_percentile
        )
    else:
        print("  WARNING: zhongshu_amplitude not found, rank_zhongshu set to NaN")
        df["rank_zhongshu"] = np.nan

    # rank_momentum
    rank_momentum_col = None
    for c in ["ret_10d", "ret_5d", "ret_3d"]:
        if c in df.columns:
            rank_momentum_col = c
            break
    if rank_momentum_col:
        df["rank_momentum"] = df.groupby("date")[rank_momentum_col].transform(
            rank_percentile
        )
    else:
        print("  WARNING: no return column found, rank_momentum set to NaN")
        df["rank_momentum"] = np.nan

    # rank_volume
    rank_vol_col = None
    for c in ["vol_ma5", "vol_ma10"]:
        if c in df.columns:
            rank_vol_col = c
            break
    if rank_vol_col:
        df["rank_volume"] = df.groupby("date")[rank_vol_col].transform(
            rank_percentile
        )
    else:
        print("  WARNING: no volume column found, rank_volume set to NaN")
        df["rank_volume"] = np.nan

    print("  Rank features added:", RANK_FEATURE_COLS)
    print()

    # -----------------------------------------------------------------------
    # Step 4: Compute PRISM-VQ prior factors
    # -----------------------------------------------------------------------
    print("[4/7] Computing PRISM-VQ prior factors...")

    if args.use_priors:
        from factor_priors import load_cached_ohlcv

        ohlcv_cols = [c for c in ["open", "high", "low", "close", "volume"] if c in df.columns]
        has_ohlcv = all(c in df.columns for c in ["open", "high", "low", "close", "volume"])

        # 初始化先验因子列为 NaN
        for col in PRIOR_COLUMNS:
            df[col] = np.nan

        symbols = df["symbol"].unique()
        n_stock = len(symbols)
        print(f"  加载 {n_stock:,} 只股票的 OHLCV（优先从缓存，否则 yfinance 下载）...")

        t_start = datetime.now()
        total_rows_processed = 0
        cache_hits = 0
        cache_misses = 0

        for s_idx, symbol in enumerate(symbols):
            if (s_idx + 1) % 100 == 0:
                elapsed = (datetime.now() - t_start).total_seconds()
                print(f"    [{s_idx+1}/{n_stock}] symbols ({total_rows_processed:,} rows, "
                      f"cache_hits={cache_hits}, cache_misses={cache_misses}, {elapsed:.0f}s)")

            # 尝试从缓存加载 OHLCV
            ohlcv = load_cached_ohlcv(symbol)
            if ohlcv is not None:
                cache_hits += 1
            elif not has_ohlcv:
                # 缓存未命中，从 yfinance 下载
                cache_misses += 1
                yf_sym = symbol if (symbol.endswith(".SS") or symbol.endswith(".SZ")) else symbol
                try:
                    import yfinance as yf
                    ticker = yf.Ticker(yf_sym)
                    ohlcv_raw = ticker.history(period="5y")
                    if ohlcv_raw.empty:
                        continue
                    ohlcv_raw = ohlcv_raw.reset_index()
                    ohlcv_raw["date"] = pd.to_datetime(ohlcv_raw["Date"]).dt.tz_localize(None)
                    ohlcv = ohlcv_raw.rename(columns={
                        "Open": "open", "High": "high", "Low": "low",
                        "Close": "close", "Volume": "volume"
                    })[["date", "open", "high", "low", "close", "volume"]]
                except Exception:
                    continue
            else:
                # 数据中有 OHLCV，直接使用
                mask = df["symbol"] == symbol
                sym_data = df.loc[mask].sort_values("date")
                ohlcv = sym_data[ohlcv_cols + ["date"]].copy()

            if ohlcv is None or len(ohlcv) < 2:
                continue

            # 获取该股票的所有行并计算先验因子
            mask = df["symbol"] == symbol
            sym_indices = df.index[mask]
            sym_data = df.loc[sym_indices].sort_values("date")

            for orig_idx, row in zip(sym_data.index, sym_data.itertuples()):
                target_date = row.date
                try:
                    # use_cache=True 表示优先从缓存读取 info/financial 数据
                    priors = compute_all_priors(ohlcv, symbol, target_date, use_cache=True)
                    for k, v in priors.items():
                        if v is not None and np.isfinite(v):
                            df.at[orig_idx, k] = v
                except Exception:
                    pass
                total_rows_processed += 1

        elapsed = (datetime.now() - t_start).total_seconds()
        print(f"  处理完成: {total_rows_processed:,} 行, "
              f"cache_hits={cache_hits}, cache_misses={cache_misses}, 耗时 {elapsed:.0f}s")

        # 统计各列非空率
        for col in PRIOR_COLUMNS:
            non_null = df[col].notna().sum()
            total = len(df)
            pct = 100.0 * non_null / total if total > 0 else 0
            print(f"    {col}: {non_null:,}/{total:,} non-null ({pct:.1f}%)")

        print(f"  先验因子列数: {len(PRIOR_COLUMNS)}")
    else:
        print("  --use-priors=False: 跳过先验因子计算")
        for col in PRIOR_COLUMNS:
            df[col] = np.nan
        print(f"  Prior columns initialized as NaN: {len(PRIOR_COLUMNS)}")

    print()

    # -----------------------------------------------------------------------
    # Step 5: Create ranking label (forward_20d_ret decile 1-10)
    # -----------------------------------------------------------------------
    print("[5/7] Creating ranking label...")

    # Compute forward_20d_ret from CLOSE PRICE (not ret_20d which is backward-looking).
    # ret_20d is a legitimate momentum FEATURE — using it as label causes leakage.
    # Priority: 1) precomputed forward_20d_ret, 2) compute from close price.
    label_source = None
    for candidate in ["forward_20d_ret"]:
        if candidate in df.columns:
            label_source = candidate
            break

    if label_source:
        print(f"  Using existing column '{label_source}' as label source")
        df["forward_20d_ret"] = df[label_source]
        n_nan = df["forward_20d_ret"].isna().sum()
        if n_nan > 0:
            print(f"  Dropping {n_nan} rows with NaN forward return ({100*n_nan/len(df):.1f}%)")
            df = df.dropna(subset=["forward_20d_ret"]).reset_index(drop=True)
    else:
        print("  Computing forward_20d_ret from close price...")
        try:
            df = compute_forward_return(df, period=20)
        except KeyError as e:
            print(f"  ERROR: Cannot compute forward return — {e}")
            print("  Need 'close' column in input data. Aborting.")
            sys.exit(1)

    # Decile rank within each date (1 = lowest forward return, 10 = highest)
    df[LABEL_COL] = (
        df.groupby("date")["forward_20d_ret"]
        .transform(lambda x: pd.qcut(x, 10, labels=False, duplicates="drop") + 1)
    )

    # If qcut fails due to ties, use rank-based alternative
    if df[LABEL_COL].isna().any():
        print("  qcut had issues (ties too many), using rank-based deciles instead")
        df[LABEL_COL] = (
            df.groupby("date")["forward_20d_ret"]
            .transform(
                lambda x: np.ceil(x.rank(method="first") / max(len(x) / 10, 1)).astype(
                    int
                )
            )
        )
        df[LABEL_COL] = df[LABEL_COL].clip(1, 10)

    label_dist = df[LABEL_COL].value_counts().sort_index()
    print(f"  Label distribution (forward return decile, 1=lowest, 10=highest):")
    for k in range(1, 11):
        count = label_dist.get(k, 0)
        print(f"    Decile {k:2d}: {count:>8,}")
    print()

    # -----------------------------------------------------------------------
    # Step 6: Add query_group column
    # -----------------------------------------------------------------------
    print("[6/7] Adding query_group column and cleaning...")

    # Sort dates and assign sequential group ID
    unique_dates = sorted(df["date"].unique())
    date_to_group = {d: i for i, d in enumerate(unique_dates)}
    df["query_group"] = df["date"].map(date_to_group).astype(int)
    print(f"  Unique dates: {len(unique_dates)}")
    print(f"  Query groups: {df['query_group'].nunique()}")

    # -----------------------------------------------------------------------
    # Step 7: Clean and filter
    # -----------------------------------------------------------------------
    print("[7/7] Filtering complete cases and saving...")

    # Determine all feature columns (including priors if enabled)
    all_expected_features = list(
        CHAN_FEATURE_COLS + V5_FEATURE_COLS + V2_QUANT_FEATURE_COLS + RANK_FEATURE_COLS
    )
    if args.use_priors:
        all_expected_features.extend(PRIOR_COLUMNS)
    
    # Ensure all feature columns exist; fill missing with NaN so they get dropped
    for col in all_expected_features:
        if col not in df.columns:
            print(f"  WARNING: column '{col}' not found in merged data, filling with NaN")
            df[col] = np.nan

    # Build output column list dynamically (including priors if enabled)
    output_cols = ID_COLS + ["query_group"] + all_expected_features + [LABEL_COL]

    # Subset to output columns
    available_out = [c for c in output_cols if c in df.columns]
    missing_out = [c for c in output_cols if c not in df.columns]
    if missing_out:
        print(f"  WARNING: output columns not available: {missing_out}")

    df_out = df[available_out].copy()

    # Track NaNs before dropping
    nan_before = df_out[all_expected_features].isna().sum().sum()
    rows_before = len(df_out)
    
    # Print NaN rates per column
    nan_rates = df_out[all_expected_features].isna().mean()
    high_nan = nan_rates[nan_rates > 0].sort_values(ascending=False)
    if len(high_nan) > 0:
        print(f"  NaN rates per column (>0%):")
        for col, rate in high_nan.items():
            print(f"    {col}: {rate*100:.1f}%")
    
    # Drop columns with >50% NaN first
    cols_to_drop = list(nan_rates[nan_rates > 0.5].index)
    if cols_to_drop:
        print(f"  Dropping {len(cols_to_drop)} columns with >50% NaN: {cols_to_drop}")
        df_out = df_out.drop(columns=cols_to_drop)
        # Update feature cols reference (not modifying list, just for dropna)
        drop_cols_internal = [c for c in all_expected_features if c not in cols_to_drop]
    else:
        drop_cols_internal = all_expected_features
    
    # Keep only rows with NO NaN in remaining feature columns
    df_out = df_out.dropna(subset=drop_cols_internal).reset_index(drop=True)

    rows_after = len(df_out)
    actual_feature_cols_in_out = [c for c in all_expected_features if c in df_out.columns]
    nan_after = df_out[actual_feature_cols_in_out].isna().sum().sum()
    dropped = rows_before - rows_after
    print(f"  Rows before dropna: {rows_before:,}")
    print(f"  Rows after dropna:  {rows_after:,}")
    print(f"  Dropped:            {dropped:,} ({100*dropped/max(rows_before,1):.1f}%)")
    print(f"  NaN values remaining in features: {nan_after}")

    # Optionally sample for testing
    if args.sample and args.sample < len(df_out):
        df_out = df_out.sample(n=args.sample, random_state=42).reset_index(drop=True)
        print(f"  Sampled to {len(df_out):,} rows for testing")

    # Save to local
    os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
    df_out.to_parquet(args.output, index=False)
    print(f"  Saved to {args.output}")

    # Also upload to HF dataset if not in sample mode
    if not args.sample:
        try:
            from huggingface_hub import HfApi
            _hf_token = os.environ.get("HF_TOKEN")
            api = HfApi(token=_hf_token)
            api.upload_file(
                path_or_fileobj=args.output,
                path_in_repo="ranking_train_data_v1.parquet",
                repo_id="cedwyh/jinjing-shared-data",
                repo_type="dataset",
            )
            print(f"  Uploaded to HF dataset: cedwyh/jinjing-shared-data/ranking_train_data_v1.parquet")
        except Exception:
            print("  WARNING: Failed to upload to HF dataset (token not exposed in logs)")
            # NOTE: token deliberately omitted from log message to avoid leaking
            #       in CI/build logs if HfApi raises an exception.

    # -----------------------------------------------------------------------
    # Summary stats
    # -----------------------------------------------------------------------
    print()
    print("=" * 60)
    print("SUMMARY STATS")
    print("=" * 60)
    print(f"  Rows:                {len(df_out):,}")
    print(f"  Columns:             {len(df_out.columns)}")
    print(f"  Feature columns:     {len(all_expected_features)}")
    print(f"  Unique dates:        {df_out['date'].nunique()}")
    print(f"  Unique symbols:      {df_out['symbol'].nunique()}")
    print(
        f"  Date range:          {df_out['date'].min()} to {df_out['date'].max()}"
    )
    print(f"  Query groups:        {df_out['query_group'].nunique()}")
    if len(df_out) > 0:
        print(f"  Label range:         {int(df_out[LABEL_COL].min())} - {int(df_out[LABEL_COL].max())}")
        print(f"  Label mean (stdev):  {df_out[LABEL_COL].mean():.4f} (+/- {df_out[LABEL_COL].std():.4f})")
    else:
        print(f"  Label range:         N/A (no data)")
    print()

    # Per-column NaN count (use columns that actually exist in the output)
    existing_feature_cols = [c for c in all_expected_features if c in df_out.columns]
    nan_counts = df_out[existing_feature_cols].isna().sum()
    nans_present = nan_counts[nan_counts > 0]
    if len(nans_present) > 0:
        print("  NaN counts per feature column:")
        for col, cnt in nans_present.items():
            print(f"    {col}: {cnt}")
    else:
        print("  All feature columns have zero NaN values.")

    print()
    print("Done.")
    print("=" * 60)


if __name__ == "__main__":
    main()