build_data_30f.py

#!/usr/bin/env python3
"""build_data_30f.py — 30F特征 -> 每日快照训练数据

A0=30F：缠引擎在30F上跑，每日取最后一条30F快照作为当日特征。
与 daily quant features (all_features_v2.parquet) 合并后训练 Ranker。

流程：
1. 加载 30F OHLCV (from HF dataset)
2. 每只股票：30F量化特征 + ChanEngine(30min) + V5 continuous features
3. 每日取最后一条30F快照
4. 合并 daily quant features
5. 创建标签 (forward_20d_ret decile)
6. 保存
"""
import os, sys, gc, warnings, time, json
from datetime import datetime
from pathlib import Path
import numpy as np
import pandas as pd

warnings.filterwarnings("ignore")

# ── env ──
DS = "cedwyh/jinjing-shared-data"
hf_token = os.environ.get("HF_TOKEN")
from huggingface_hub import HfApi, hf_hub_download
api = HfApi()

# ── chan engine setup ──
# Download and extract chan engine tarball
TARBALL = "chan_engine_v5.5.1.tar.gz"
ENGINE_DIR = "/tmp/chan_engine"

def _ensure_engine():
    if os.path.exists(ENGINE_DIR):
        return
    import tarfile
    p = hf_hub_download(repo_id=DS, filename=TARBALL, repo_type="dataset")
    # Extract into engine_chan_v3/ subdirectory
    os.makedirs(ENGINE_DIR, exist_ok=True)
    with tarfile.open(p) as f:
        # The tarball has no subdirectory prefix, extract into engine_chan_v3/
        for member in f.getmembers():
            member.name = f"engine_chan_v3/{member.name}"
            f.extract(member, path="/tmp")
    # Verify
    init_file = os.path.join(ENGINE_DIR, "__init__.py")
    if not os.path.exists(init_file):
        Path(init_file).touch()
    print(f"  Chan engine extracted to {ENGINE_DIR}")

_ensure_engine()
sys.path.insert(0, "/tmp")  # engine_chan_v3/ is at /tmp/engine_chan_v3/
import engine_chan_v3
from engine_chan_v3.engine import ChanEngineV3
from engine_chan_v3.features import compute_continuous_features
from engine_chan_v3.chan_config import ChanConfig
from engine_chan_v3.bspoints import BuySellType as BST

# ── constants ──
EPOCH = datetime(1970, 1, 1)

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

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",
]

# 30F 特征 = 仅 chan engine 特征（量化特征用日线 all_features_v2.parquet）
ALL_30F_FEATURES = CHAN_FEATURE_COLS + V5_FEATURE_COLS

# ── helpers ──
def rank_percentile(series):
    ranks = series.rank(method="average", ascending=True)
    return (ranks - 1) / max(ranks.max() - 1, 1)


def compute_30f_features(sym_df):
    """Compute 30F chan engine features for one stock.
    Only initializes placeholder columns — actual values filled by run_chan_engine_30f()."""
    n = len(sym_df)
    feat = pd.DataFrame(index=sym_df.index)
    feat["symbol"] = sym_df["symbol"].values
    feat["datetime"] = sym_df["datetime"].values
    feat["date"] = pd.to_datetime(sym_df["datetime"]).dt.date.astype(str)

    # Initialize placeholder columns
    for col in CHAN_FEATURE_COLS + V5_FEATURE_COLS:
        feat[col] = 0.0

    return feat


def run_chan_engine_30f(sym_df, feat_df, engine, sym_name):
    """Run ChanEngineV3 with 30min config, populate V5 and buy/sell features."""
    n = len(sym_df)

    # Prepare DataFrame with column names expected by chan engine
    chan_input = sym_df.rename(columns={
        "datetime": "date",
        "open": "open",
        "high": "high",
        "low": "low",
        "close": "close",
        "volume": "volume",
    })
    # Ensure date is datetime
    chan_input["date"] = pd.to_datetime(chan_input["date"])

    # NOTE: engine already initialized with ChanConfig.for_frequency("30min") in main()
    # Do NOT reassign engine.config here — ChanConfig is a dataclass without .get(),
    # and engine internally uses config.get() which will fail silently.
    # See verify_30f_v8.py:30F-features-all-zero root cause

    result_dict = engine.analyze(chan_input)
    if not result_dict.get("success") or result_dict.get("result") is None:
        return

    result = result_dict["result"]

    # V5 continuous features
    cf = compute_continuous_features(result, chan_input)
    for name in V5_FEATURE_COLS + ["bi_strength", "zhongshu_amplitude", "bi_zhongshu_count"]:
        arr = cf.get(name)
        if arr is not None and len(arr) == n:
            feat_df[name] = arr.astype(np.float64)

    # Buy/sell points
    buy1 = np.zeros(n, dtype=np.int32)
    buy2 = np.zeros(n, dtype=np.int32)
    buy3 = np.zeros(n, dtype=np.int32)
    sell1 = np.zeros(n, dtype=np.int32)
    sell2 = np.zeros(n, dtype=np.int32)
    sell3 = np.zeros(n, dtype=np.int32)
    last_buy = -1

    for bp in result.bspoints:
        idx = bp.kline_idx
        if idx < 0 or idx >= n:
            continue
        if bp.bstype == BST.BUY1:   buy1[idx] = 1; last_buy = idx
        elif bp.bstype == BST.BUY2: buy2[idx] = 1; last_buy = idx
        elif bp.bstype == BST.BUY3: buy3[idx] = 1; last_buy = idx
        elif bp.bstype == BST.SELL1: sell1[idx] = 1
        elif bp.bstype == BST.SELL2: sell2[idx] = 1
        elif bp.bstype == BST.SELL3: sell3[idx] = 1

    feat_df["buy1"] = buy1
    feat_df["buy2"] = buy2
    feat_df["buy3"] = buy3
    feat_df["sell1"] = sell1
    feat_df["sell2"] = sell2
    feat_df["sell3"] = sell3

    # dist_last_buy
    distances = np.full(n, 9999, dtype=np.int32)
    if last_buy >= 0:
        distances[last_buy] = 0
        for i in range(last_buy + 1, n):
            distances[i] = distances[i-1] + 1
    feat_df["dist_last_buy"] = distances


def main():
    t0 = time.time()

    print("=" * 60)
    print("30F Fire Eye V8 — Training Data Builder")
    print("A0 = 30min (8 bars/day)")
    print("=" * 60)
    print()

    # ── Step 1: Load 30F OHLCV ──
    print("[1/6] Loading 30F OHLCV from HF...")
    ohlcv_path = hf_hub_download(repo_id=DS, filename="ohlcv_30m.parquet", repo_type="dataset")
    print(f"  Downloading {ohlcv_path}...")

    # Read in chunks to avoid OOM
    import pyarrow.parquet as pq
    pf = pq.ParquetFile(ohlcv_path)
    n_rows = pf.metadata.num_rows
    print(f"  Total rows: {n_rows:,}")

    # Group by symbol in the script
    symbols_df = pd.read_parquet(ohlcv_path, columns=["symbol"])
    all_symbols = sorted(symbols_df["symbol"].unique())
    print(f"  Unique symbols: {len(all_symbols)}")

    # ── Step 2: Init chan engine ──
    print("[2/6] Initializing ChanEngineV3 (A0=30min)...")
    engine = ChanEngineV3(config=ChanConfig.for_frequency("30min"))

    # ── Step 3: Process each symbol ──
    print("[3/6] Computing 30F features per symbol...")
    snapshots = []
    t_start = time.time()
    n_processed = 0
    n_errors = 0

    # Collect daily close prices for label computation
    daily_closes = []

    for s_idx, symbol in enumerate(all_symbols):
        if (s_idx + 1) % 100 == 0:
            elapsed = time.time() - t_start
            rate = (s_idx + 1) / elapsed
            eta = (len(all_symbols) - s_idx - 1) / rate if rate > 0 else 0
            print(f"  [{s_idx+1}/{len(all_symbols)}] {symbol} | {elapsed:.0f}s elapsed, ETA {eta:.0f}s")

        try:
            # Read this symbol's data
            sym_data = pd.read_parquet(
                ohlcv_path,
                filters=[("symbol", "=", symbol)],
                columns=["symbol", "datetime", "open", "high", "low", "close", "volume"],
            )
            sym_data = sym_data.sort_values("datetime").reset_index(drop=True)

            if len(sym_data) < 160:  # need at least 20 trading days
                n_errors += 1
                continue

            # Compute 30F features
            feat = compute_30f_features(sym_data)

            # Run chan engine
            run_chan_engine_30f(sym_data, feat, engine, symbol)

            # Take last bar per day as daily snapshot
            feat["date"] = pd.to_datetime(feat["datetime"]).dt.date.astype(str)
            daily_last = feat.groupby("date").last().reset_index()

            # Extract daily close price for forward return computation
            sym_data["date_str"] = pd.to_datetime(sym_data["datetime"]).dt.date.astype(str)
            daily_close = sym_data.groupby("date_str").last()[["close"]].reset_index()
            daily_close.columns = ["date", "close"]
            daily_close["symbol"] = symbol
            daily_closes.append(daily_close[["date", "symbol", "close"]])

            # Keep only needed columns
            keep = ["date", "symbol"] + ALL_30F_FEATURES
            available = [c for c in keep if c in daily_last.columns]
            snapshots.append(daily_last[available])

            n_processed += 1

        except Exception as e:
            n_errors += 1
            if n_errors <= 5:
                print(f"  ⚠️ Error processing {symbol}: {e}")
            continue

    print(f"  Processed: {n_processed}/{len(all_symbols)}, Errors: {n_errors}")
    print(f"  Time: {time.time() - t_start:.0f}s")

    if not snapshots:
        print("  ❌ No snapshots generated!")
        sys.exit(1)

    # ── Step 4: Combine snapshots ──
    print("[4/6] Combining daily snapshots...")
    df_30f = pd.concat(snapshots, ignore_index=True)
    df_30f["date"] = pd.to_datetime(df_30f["date"])
    print(f"  30F snapshot features: {len(df_30f):,} rows x {len(df_30f.columns)} cols")
    print(f"  Unique dates: {df_30f['date'].nunique()}")
    print(f"  Date range: {df_30f['date'].min().date()} → {df_30f['date'].max().date()}")

    # ── Step 5: Merge with daily quant features ──
    print("[5/6] Merging with daily quant features...")
    v2_path = hf_hub_download(repo_id=DS, filename="all_features_v2.parquet", repo_type="dataset")
    df_v2 = pd.read_parquet(v2_path)

    # Normalize dates
    df_30f["date"] = pd.to_datetime(df_30f["date"], format="mixed").dt.strftime("%Y-%m-%d")
    df_v2["date"] = pd.to_datetime(df_v2["date"], format="mixed").dt.strftime("%Y-%m-%d")
    df_v2["symbol"] = df_v2["symbol"].astype(str)
    df_30f["symbol"] = df_30f["symbol"].astype(str)

    # Select V2 quant columns (non-chan features)
    v2_quant = [
        "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",
    ]
    v2_keep = ["date", "symbol"] + [c for c in v2_quant if c in df_v2.columns]
    # Also keep price columns for forward return
    for c in ["close", "open", "high", "low", "volume"]:
        if c in df_v2.columns and c not in v2_keep:
            v2_keep.append(c)

    df_v2_sub = df_v2[v2_keep].copy()

    # Merge: 30F features (left) + V2 quant (right)
    df = pd.merge(df_30f, df_v2_sub, on=["date", "symbol"], how="inner")
    print(f"  Merged with V2: {len(df):,} rows x {len(df.columns)} cols")

    # Merge daily close prices (from 30F data)
    if daily_closes:
        df_close = pd.concat(daily_closes, ignore_index=True)
        df_close["date"] = pd.to_datetime(df_close["date"], format="mixed").dt.strftime("%Y-%m-%d")
        df_close["symbol"] = df_close["symbol"].astype(str)
        pre = len(df)
        df = pd.merge(df, df_close, on=["date", "symbol"], how="left")
        print(f"  Merged close prices: {len(df):,} rows (from {pre:,})")
        # Report close NaN rate
        close_nan = df["close"].isna().sum()
        if close_nan > 0:
            print(f"  ⚠️ {close_nan} rows missing close price ({100*close_nan/len(df):.1f}%)")

    # ── Step 6: Rank features + Label ──
    print("[6/6] Creating rank features and label...")

    # Cross-sectional rank features
    if "bi_strength" in df.columns:
        df["rank_bi_strength"] = df.groupby("date")["bi_strength"].transform(rank_percentile)

    if "zhongshu_amplitude" in df.columns:
        df["rank_zhongshu"] = df.groupby("date")["zhongshu_amplitude"].transform(rank_percentile)

    # rank_momentum: use daily ret_20d (available after merge with V2)
    rank_mom_col = None
    for c in ["ret_20d", "ret_10d", "ret_5d"]:
        if c in df.columns:
            rank_mom_col = c
            break
    if rank_mom_col:
        df["rank_momentum"] = df.groupby("date")[rank_mom_col].transform(rank_percentile)

    # rank_volume
    rank_vol_col = None
    for c in ["vol_ma5", "vol_ma20"]:
        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)

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

    # Labels: forward Nd return deciles for multiple horizons
    # Use daily close price (merged from 30F data)
    HORIZONS = [5, 10, 20]
    if "close" in df.columns:
        df = df.sort_values(["symbol", "date"]).reset_index(drop=True)

        # Compute forward returns for all horizons simultaneously
        for N in HORIZONS:
            df[f"forward_{N}d_ret"] = df.groupby("symbol")["close"].transform(
                lambda x: x.shift(-N) / x - 1
            )

        # Drop rows where the LONGEST horizon has NaN (most conservative)
        n_before = len(df)
        df = df.dropna(subset=[f"forward_{HORIZONS[-1]}d_ret"]).reset_index(drop=True)
        n_dropped = n_before - len(df)
        print(f"  Dropped {n_dropped} rows with NaN forward return (longest horizon={HORIZONS[-1]}d)")

        # Generate decile labels for each horizon
        for N in HORIZONS:
            col = f"forward_{N}d_ret"
            label_col = f"label_rank_{N}d"
            df[label_col] = (
                df.groupby("date")[col]
                .transform(lambda x: pd.qcut(x, 10, labels=False, duplicates="drop") + 1)
            )
            # Fill any NaN labels (from dates with too few stocks)
            if df[label_col].isna().any():
                n_filled = df[label_col].isna().sum()
                df[label_col] = (
                    df.groupby("date")[col]
                    .transform(lambda x: np.ceil(x.rank(method="first") / max(len(x) / 10, 1)).astype(int).clip(1, 10))
                )
                print(f"    Filled {n_filled} NaN labels for {N}d horizon")

        print(f"  Label distributions:")
        for N in HORIZONS:
            label_col = f"label_rank_{N}d"
            print(f"    --- {N}d horizon ---")
            for k, v in sorted(df[label_col].value_counts().items()):
                print(f"      Decile {int(k):2d}: {v:>8,}")
    else:
        print("  ⚠️ No price column found, cannot compute forward return labels")
        for N in HORIZONS:
            df[f"label_rank_{N}d"] = np.nan

    # Use 20d as default label_rank (for train_ranker backward compat)
    df["label_rank"] = df["label_rank_20d"]

    # Query group
    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)

    # Feature cols
    all_features = ALL_30F_FEATURES + [c for c in v2_quant if c in df.columns] + RANK_FEATURE_COLS
    all_features = [c for c in all_features if c in df.columns]
    print(f"  Total feature columns: {len(all_features)}")

    # Label distribution
    print(f"  Label range: {int(df['label_rank'].min())} - {int(df['label_rank'].max())}")
    print(f"  Label mean: {df['label_rank'].mean():.4f}")

    # ── Save ──
    output_cols = ["date", "symbol", "query_group", "close"] + all_features + [f"label_rank_{N}d" for N in HORIZONS] + ["label_rank"]
    output_cols = [c for c in output_cols if c in df.columns]

    df_out = df[output_cols].copy()

    # Drop NaN in features
    rows_before = len(df_out)
    df_out = df_out.dropna(subset=all_features).reset_index(drop=True)
    print(f"  Rows after dropna: {len(df_out):,} (dropped {rows_before - len(df_out):,})")

    # Save
    out_path = "/tmp/ranking_train_30f.parquet"
    df_out.to_parquet(out_path, index=False)
    print(f"  Saved to {out_path}")

    # Upload
    try:
        api = HfApi()
        api.upload_file(
            path_or_fileobj=out_path,
            path_in_repo="ranking_train_30f_v1.parquet",
            repo_id=DS,
            repo_type="dataset",
        )
        print("  ✅ Uploaded to HF dataset")
    except Exception as e:
        print(f"  ⚠️ Upload failed: {e}")

    # Summary
    elapsed = time.time() - t0
    print()
    print("=" * 60)
    print("SUMMARY")
    print("=" * 60)
    print(f"  Rows:            {len(df_out):,}")
    print(f"  Columns:         {len(df_out.columns)}")
    print(f"  Feature columns: {len(all_features)}")
    print(f"  Unique dates:    {df_out['date'].nunique()}")
    print(f"  Date range:      {df_out['date'].min()} → {df_out['date'].max()}")
    print(f"  Unique symbols:  {df_out['symbol'].nunique()}")
    print(f"  NaN in features: {df_out[all_features].isna().sum().sum()}")
    print(f"  Total time:      {elapsed:.0f}s ({elapsed/60:.1f}min)")
    print("Done.")


if __name__ == "__main__":
    main()