Upload scripts

scripts/inference.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+加载已训练追踪器，处理新交易日。
+
+用法:
+  # 处理单个新日
+  python scripts/inference.py --date 20260401 --tracker outputs/tracker_state.pkl --output outputs/new_day/
+
+  # 批量处理
+  python scripts/inference.py --date 20260401,20260402,20260403 --tracker outputs/tracker_state.pkl
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from src.data.loader import load_l2_day, BLACKLIST_DATES
+from src.features.passive_orders import (
+    compute_vwap,
+    extract_passive_orders,
+    prepare_features,
+    select_candidates,
+)
+from src.clustering.daily_cluster import cluster_candidates
+from src.matching.cross_day_match import match_multi_window
+from src.tracking.entity_tracker import EntityTracker
+
+
+def process_new_day(
+    tracker: EntityTracker,
+    date: int,
+    max_cost: float = 3.5,
+) -> dict:
+    """处理一个新交易日，更新追踪器并返回信号。"""
+    if date in BLACKLIST_DATES:
+        print(f"[{date}] blacklisted, skip")
+        return {"date": date, "score": 0.0, "error": "blacklisted"}
+
+    # 加载数据
+    try:
+        data = load_l2_day(date)
+    except Exception as e:
+        print(f"[{date}] load failed: {e}")
+        return {"date": date, "score": 0.0, "error": str(e)}
+
+    trades = data["trades"]
+    if "is_cancellation" in trades.columns:
+        trades = trades[~trades["is_cancellation"]]
+    trades = trades[trades["bs_flag_desc"].isin(["active_buy", "active_sell"])]
+    if trades.empty:
+        return {"date": date, "score": 0.0, "error": "empty trades"}
+
+    # 被动单 + 聚类
+    vwap = compute_vwap(trades)
+    passive = extract_passive_orders(trades, vwap)
+    candidates = select_candidates(passive, top_n=150)
+    if candidates.empty or len(candidates) < 5:
+        return {"date": date, "score": 0.0, "error": "too few candidates"}
+
+    feats = prepare_features(candidates)
+    _, centroids = cluster_candidates(candidates, feats)
+
+    if not centroids:
+        return {"date": date, "score": 0.0, "n_clusters": 0}
+
+    # 跨日匹配：往前看最近已处理日
+    recent = {}
+    for prev_date in sorted(tracker._processed_dates)[-2:]:
+        # 收集该日的簇信息（通过 cluster_registry 反查）
+        day_clusters = {
+            cid: tracker.entities[eid]
+            for (d, cid), eid in tracker.cluster_registry.items()
+            if d == prev_date and eid in tracker.entities
+        }
+        if day_clusters:
+            # 重建 centroid 信息（用最近一次记录的）
+            recent[prev_date] = {}
+            for cid, e in day_clusters.items():
+                if e.get("centroids"):
+                    recent[prev_date][int(cid)] = {
+                        "centroid_scaled": e["centroids"][-1][1]
+                        if isinstance(e["centroids"][-1], tuple)
+                        else e["centroids"][-1],
+                        "centroid": e["centroids"][-1][1]
+                        if isinstance(e["centroids"][-1], tuple)
+                        else e["centroids"][-1],
+                        "total_amount": e.get("total_amount_latest", 0),
+                        "size": e.get("cluster_count", 1),
+                        "dominant_side": e.get("dominant_sides", ["unknown"])[-1],
+                        "bid_ratio": e.get("bid_ratio", 0.5),
+                    }
+
+    matches = match_multi_window(date, centroids, recent, max_cost=max_cost)
+
+    # 更新追踪器
+    tracker.process_day(date, centroids, matches)
+    signal = tracker.compute_position_signal(date)
+    signal["date"] = date
+
+    print(
+        f"[{date}] clusters={len(centroids)}, "
+        f"matches={len(matches)}, "
+        f"entities={len(tracker.entities)}, "
+        f"score={signal['score']:.4f}"
+    )
+
+    return signal
+
+
+def main():
+    parser = argparse.ArgumentParser(description="新日推理")
+    parser.add_argument("--date", required=True, help="日期 YYYYMMDD，多个用逗号分隔")
+    parser.add_argument("--tracker", default="./outputs/tracker_state.pkl", help="追踪器状态文件")
+    parser.add_argument("--output", default="./outputs/new_day", help="输出目录")
+    parser.add_argument("--save-state", action="store_true", help="推理后保存更新状态")
+    args = parser.parse_args()
+
+    # 加载追踪器
+    print(f"Loading tracker from {args.tracker}")
+    tracker = EntityTracker.load_state(args.tracker)
+    print(f"  Loaded: {len(tracker.entities)} entities, {len(tracker._processed_dates)} processed days")
+    print(f"  Last processed: {max(tracker._processed_dates) if tracker._processed_dates else 'N/A'}")
+
+    dates = [int(d.strip()) for d in args.date.split(",")]
+
+    os.makedirs(args.output, exist_ok=True)
+
+    signals = []
+    for date in sorted(dates):
+        sig = process_new_day(tracker, date)
+        signals.append(sig)
+
+    signals_df = pd.DataFrame(signals)
+
+    # 合并历史信号
+    hist_signals = tracker.get_daily_signals()
+    all_signals = pd.concat([hist_signals, signals_df], ignore_index=True)
+
+    sig_path = os.path.join(args.output, "position_signal_daily.parquet")
+    all_signals.to_parquet(sig_path)
+    print(f"\nSignals saved to {sig_path}")
+
+    if args.save_state:
+        state_path = os.path.join(args.output, "tracker_state_updated.pkl")
+        tracker.save_state(state_path)
+
+    # 最新信号
+    print("\n===== 最新信号 =====")
+    for sig in signals:
+        print(
+            f"  {sig['date']}: score={sig.get('score', 'N/A')}, "
+            f"bid={sig.get('bid_entities', 'N/A')}, "
+            f"ask={sig.get('ask_entities', 'N/A')}"
+        )
+
+
+if __name__ == "__main__":
+    main()

scripts/run_hf_jobs.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+HF Jobs 全量运行脚本：流水线 + 结果上传到 HF Dataset。
+
+在 HF Jobs 中运行：
+  hf jobs run --flavor cpu-large --timeout 12h --detach --secrets HF_TOKEN \\
+    --env DATASET_REPO=kangkangchen/cross-day-mainforce-600809 \\
+    pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime -- \\
+    /bin/sh -lc '
+      pip install pandas pyarrow numpy scipy scikit-learn huggingface_hub tqdm
+      python scripts/run_hf_jobs.py
+    '
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from huggingface_hub import HfApi, create_repo, upload_folder
+
+from src.scripts.pipeline import run_pipeline
+
+
+def generate_dates(start: int, end: int):
+    """生成交易日期列表（周一-周五，排除黑名单）。"""
+    from datetime import timedelta
+    from src.data.loader import BLACKLIST_DATES
+
+    start_dt = datetime.strptime(str(start), "%Y%m%d")
+    end_dt = datetime.strptime(str(end), "%Y%m%d")
+    dates = []
+    curr = start_dt
+    while curr <= end_dt:
+        d = int(curr.strftime("%Y%m%d"))
+        if d not in BLACKLIST_DATES and curr.weekday() < 5:
+            dates.append(d)
+        curr += timedelta(days=1)
+    return dates
+
+
+def main():
+    output_base = os.environ.get("OUTPUT_DIR", "./outputs")
+    dataset_repo = os.environ.get("DATASET_REPO", "kangkangchen/cross-day-mainforce-600809")
+    start_date = int(os.environ.get("START_DATE", "20230101"))
+    end_date = int(os.environ.get("END_DATE", "20260331"))
+
+    print(f"===== Cross-Day Main Force Pipeline =====")
+    print(f"Range: {start_date} ~ {end_date}")
+    print(f"Output: {output_base}")
+    print(f"Target dataset: {dataset_repo}")
+    print(f"Start: {datetime.now().isoformat()}")
+
+    # 1. 确保数据集 repo 存在
+    api = HfApi()
+    try:
+        create_repo(dataset_repo, repo_type="dataset", exist_ok=True)
+        print(f"Dataset repo {dataset_repo} ready")
+    except Exception as e:
+        print(f"Create repo warning: {e}")
+
+    # 2. 生成日期 & 运行流水线
+    dates = generate_dates(start_date, end_date)
+    print(f"Total trading days: {len(dates)}")
+
+    run_pipeline(dates, output_base, save_intermediate=False)
+
+    # 3. 复制源码到输出目录（方便 dataset 自包含）
+    import shutil
+    src_dest = os.path.join(output_base, "src")
+    if os.path.exists(src_dest):
+        shutil.rmtree(src_dest)
+    shutil.copytree("src", src_dest)
+    shutil.copy("DESIGN.md", os.path.join(output_base, "DESIGN.md"))
+    shutil.copy("README.md", os.path.join(output_base, "README.md"))
+
+    # 4. 写到 dataset README
+    write_dataset_readme(output_base)
+
+    # 5. 上传到 HF Dataset
+    print(f"\nUploading to {dataset_repo} ...")
+    upload_folder(
+        repo_id=dataset_repo,
+        folder_path=output_base,
+        repo_type="dataset",
+        commit_message=f"Full run {start_date}-{end_date} @ {datetime.now().isoformat()}",
+    )
+    print(f"Upload complete: https://huggingface.co/datasets/{dataset_repo}")
+
+    print(f"\nDone: {datetime.now().isoformat()}")
+
+
+def write_dataset_readme(output_base: str):
+    """生成 dataset 的 README（包含模型使用说明）。"""
+    readme = """---
+license: mit
+task_categories:
+- time-series-forecasting
+tags:
+- finance
+- a-share
+- level-2
+- main-force
+- position-tracking
+pretty_name: Cross-Day Main Force Position Inference for 600809.SH
+---
+
+# Cross-Day Main Force Position Inference for 600809.SH
+
+跨日主力行为指纹追踪——不追踪"谁"，追踪"某种行为模式在增强还是衰减"。
+
+## 数据
+
+- 股票: `600809.SH` (山西汾酒)
+- 覆盖区间: 2023-01-01 ~ 2026-03-31
+- 数据源: [a-share-l2-600809](https://huggingface.co/datasets/kangkangchen/a-share-l2-600809)
+
+## 核心方法
+
+上交所 L2 order_id 每日重置，无法跨日追踪同一账户。本方案利用**行为指纹**跨日匹配：
+
+1. **被动单提取**: 利用 `active_buy → ask_order_id`, `active_sell → bid_order_id` 语义，每日提取 top 150 被动挂单的行为特征
+2. **日级聚类**: OPTICS 密度聚类，发现"主力行为模式"
+3. **跨日匹配**: 匈牙利算法 + T→T+1/T+2 多窗口匹配
+4. **实体追踪**: 匹配对连成实体链，追踪金额/方向趋势
+5. **仓位推断**: 聚合活跃实体，计算日级主力仓位方向
+
+详细设计见 [DESIGN.md](./DESIGN.md)。
+
+## 输出文件
+
+| 文件 | 内容 |
+|---|---|
+| `entity_timeline.parquet` | 每个实体的完整生命周期（first_seen, last_seen, dominant_side, amount_growth 等）|
+| `cluster_registry.parquet` | 每日每个簇到实体的映射 |
+| `signals/position_signal_daily.parquet` | **日级仓位推断信号**（核心输出） |
+| `matches/match_pairs.parquet` | 跨日匹配记录 |
+| `tracker_state.pkl` | 完整追踪器状态（可加载继续处理新日） |
+| `reports/summary.json` | 汇总���计 |
+
+## 信号字段说明
+
+`position_signal_daily.parquet` 核心字段：
+
+| 字段 | 含义 |
+|---|---|
+| `date` | 交易日 YYYYMMDD |
+| `score` | 仓位方向原始分（正值=吸筹倾向，负值=出货倾向） |
+| `score_z` | 滚动 20 日 z-score 归一化后的分值 |
+| `bid_entities` | 当日活跃的买方实体数 |
+| `ask_entities` | 当日活跃的卖方实体数 |
+| `n_active_entities` | 当日活跃实体总数 |
+| `n_total_entities` | 历史累计发现的实体总数 |
+| `accumulation_entities` | 正在扩张的买方实体 ID 列表 |
+| `distribution_entities` | 正在扩张的卖方实体 ID 列表 |
+
+**重要**: 所有分数和概率都应读成"证据强度"，不是交易信号，不是买卖建议。
+
+## 如何使用（加载模型处理新日）
+
+### 1. 加载已训练的追踪器
+
+```python
+import sys
+sys.path.insert(0, 'src/')
+from src.tracking.entity_tracker import EntityTracker
+
+# 加载追踪器状态
+tracker = EntityTracker.load_state("tracker_state.pkl")
+print(f"Loaded: {len(tracker.entities)} entities")
+print(f"Last date: {max(tracker._processed_dates)}")
+```
+
+### 2. 处理新交易日
+
+```python
+import sys
+sys.path.insert(0, 'src/')
+from scripts.inference import process_new_day
+
+# 处理单个新日
+signal = process_new_day(tracker, 20260401)
+print(f"Score: {signal['score']:.4f}, bid={signal['bid_entities']}, ask={signal['ask_entities']}")
+```
+
+### 3. 批量推理
+
+```bash
+python scripts/inference.py \
+  --date 20260401,20260402,20260403 \
+  --tracker outputs/tracker_state.pkl \
+  --save-state
+```
+
+### 4. 查看实体详情
+
+```python
+import pandas as pd
+entities = pd.read_parquet("entity_timeline.parquet")
+
+# 最活跃的买方实体
+entities[entities['dominant_side'] == 'bid'].nlargest(10, 'active_days')
+
+# 按金额增长排
+entities.nlargest(10, 'amount_growth')
+```
+
+## 信号解读指南
+
+1. **score_z > 1.5**: 当日买方实体扩张显著强于卖方，可能有吸筹行为
+2. **score_z < -1.5**: 卖方实体扩张显著强于买方，可能有出货行为
+3. **bid_entities 持续 > ask_entities + 3**: 多日买方实体占优，可能处于吸筹阶段
+4. **实体集中新生/退出**: 旧实体批量退出 + 新实体批量出现 = 主力换防事件
+
+⚠️ 信号需要结合盘口复盘（价格、成交量、OBI 变化）验证，不可单独使用。
+
+## 校验
+
+与 Tushare `moneyflow_dc_daily` 主力净流入对比，确认推断方向不严重矛盾：
+
+```bash
+python scripts/validate_with_moneyflow.py \
+  --signal outputs/signals/position_signal_daily.parquet
+```
+
+## 限制
+
+- 仅 600809.SH 单只股票
+- 不预测涨跌，只输出行为仓位方向
+- 每日仅 150 个候选被动单，可能遗漏小主力
+- 主力换防事件的识别依赖匹配阈值调优
+- 需要至少 10 个交易日的历史才能产生有意义信号
+
+## 研究声明
+
+本项目仅供研究学习，不构成投资建议。所有分数、信号和实体标签都需要结合原始盘口数据和人工经验复核。
+"""
+
+    with open(os.path.join(output_base, "README.md"), "w") as f:
+        f.write(readme)
+    print("Dataset README written.")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_hf_sandbox.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# HF Sandbox / Jobs 全量运行脚本
+# 用法: bash scripts/run_hf_sandbox.sh
+
+set -e
+
+echo "===== Cross-Day Main Force Position Inference ====="
+echo "Start: $(date)"
+
+# 安装依赖（HF sandbox 里 huggingface_hub 通常已预装）
+pip install -q pandas pyarrow numpy scipy scikit-learn tqdm
+
+# 全量流水线
+python src/scripts/pipeline.py \
+  --start 20230101 \
+  --end 20260331 \
+  --output ./outputs \
+  --full \
+  --save-intermediate
+
+echo "===== Done: $(date) ====="
+echo "Output files:"
+find ./outputs -type f -name "*.parquet" -o -name "*.json" | sort

scripts/run_local_test.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+本地最小验证：5 个交易日，验证 pipeline 正确性。
+
+用法：
+  python scripts/run_local_test.py
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# 保证项目根在 path 里
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from src.data.loader import load_l2_day, BLACKLIST_DATES
+from src.features.passive_orders import (
+    compute_vwap,
+    extract_passive_orders,
+    prepare_features,
+    select_candidates,
+)
+from src.clustering.daily_cluster import cluster_candidates
+from src.matching.cross_day_match import match_clusters, match_multi_window
+from src.tracking.entity_tracker import EntityTracker
+
+# 测试日期：2024年3月第二周（避开黑名单）
+TEST_DATES = [20240311, 20240312, 20240313, 20240314, 20240315]
+
+OUTPUT_DIR = os.path.join(
+    os.path.dirname(__file__), "..", "outputs", "local_test"
+)
+
+
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    print(f"本地测试: {len(TEST_DATES)} 天, 输出目录: {OUTPUT_DIR}\n")
+
+    tracker = EntityTracker(inactive_threshold=5)
+    recent_history = {}
+
+    for i, date in enumerate(TEST_DATES):
+        print(f"--- {date} ---")
+
+        # 1. 加载
+        try:
+            data = load_l2_day(date)
+        except Exception as e:
+            print(f"  SKIP: 加载失败 ({e})")
+            continue
+
+        trades = data["trades"]
+        orders = data["orders"]
+        if "is_cancellation" in trades.columns:
+            trades = trades[~trades["is_cancellation"]]
+
+        print(f"  trades={len(trades):,}, orders={len(orders):,}")
+
+        # 2. VWAP + 被动单
+        vwap = compute_vwap(trades)
+        passive = extract_passive_orders(trades, vwap)
+        candidates = select_candidates(passive, top_n=150)
+        print(f"  passive_orders={len(passive):,}, candidates={len(candidates)}")
+        print(f"  VWAP={vwap:.2f}, bid_candidates={len(candidates[candidates['side']=='bid'])}, ask_candidates={len(candidates[candidates['side']=='ask'])}")
+
+        if candidates.empty:
+            recent_history[date] = {}
+            continue
+
+        # 3. 聚类
+        feats = prepare_features(candidates)
+        labeled, centroids = cluster_candidates(candidates, feats)
+        n_clusters = len(centroids)
+        n_noise = (labeled["cluster_id"] == -1).sum()
+        print(f"  clusters={n_clusters}, noise={n_noise}")
+
+        # 4. 跨日匹配
+        prev_dates = sorted(
+            [d for d in recent_history.keys() if d < date]
+        )[-2:]
+        prev_c_for_match = {}
+        for pd_ in prev_dates:
+            if recent_history.get(pd_):
+                prev_c_for_match[pd_] = recent_history[pd_]
+
+        matches = match_multi_window(date, centroids, prev_c_for_match)
+        print(f"  matches={len(matches)}")
+        for m in matches:
+            print(f"    {m[0]} c{m[1]} → {m[2]} cost={m[3]:.3f}")
+
+        # 5. 实体追踪
+        cid_to_eid = tracker.process_day(date, centroids, matches)
+        print(f"  entity mapping: {cid_to_eid}")
+
+        # 6. 仓位推断
+        signal = tracker.compute_position_signal(date)
+        print(f"  signal: score={signal['score']:.4f}, bid_entities={signal['bid_entities']}, ask_entities={signal['ask_entities']}")
+
+        recent_history[date] = centroids
+
+    # ---- 导出 ----
+    print("\n===== 导出 =====")
+
+    entity_df = tracker.get_entity_timeline()
+    print(f"实体总数: {len(entity_df)}")
+    print(entity_df.to_string())
+
+    entity_path = os.path.join(OUTPUT_DIR, "entity_timeline.parquet")
+    entity_df.to_parquet(entity_path)
+    print(f"实体表 → {entity_path}")
+
+    signals_df = tracker.get_daily_signals()
+    signals_path = os.path.join(OUTPUT_DIR, "position_signal_daily.parquet")
+    signals_df.to_parquet(signals_path)
+    print(f"信号表 → {signals_path}")
+    print(signals_df[["date", "score", "score_z", "n_active_entities"]].to_string())
+
+    # 被动单样本（第一天）
+    passive_path = os.path.join(OUTPUT_DIR, "sample_passive_orders.parquet")
+    passive.to_parquet(passive_path)
+    print(f"被动单样本 → {passive_path}")
+
+    # 聚类样本
+    cluster_path = os.path.join(OUTPUT_DIR, "sample_clusters.parquet")
+    labeled.to_parquet(cluster_path)
+    print(f"聚类样本 → {cluster_path}")
+
+    print("\n===== 本地验证完成 =====")
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_with_moneyflow.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+校验：将推断的主力仓位信号与 Tushare moneyflow_dc 的主力净流入做相关性检查。
+
+这不是拟合目标——只是 sanity check，确认推断方向不与外部数据严重矛盾。
+
+用法:
+  python scripts/validate_with_moneyflow.py --signal outputs/signals/position_signal_daily.parquet
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import pearsonr, spearmanr
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from src.data.loader import load_tushare_table
+from huggingface_hub import snapshot_download
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--signal", required=True, help="position_signal_daily.parquet 路径")
+    parser.add_argument("--output-dir", default="./outputs/reports")
+    args = parser.parse_args()
+
+    # 加载信号
+    signal = pd.read_parquet(args.signal)
+    signal["date"] = signal["date"].astype(int)
+
+    # 下载并加载 moneyflow_dc
+    tushare_root = snapshot_download(
+        "kangkangchen/a-share-tushare-context-600809",
+        repo_type="dataset",
+        allow_patterns=["data/moneyflow_dc_daily/**/*.parquet"],
+    )
+    mf = load_tushare_table(tushare_root, "moneyflow_dc_daily")
+    if mf.empty:
+        print("ERROR: moneyflow_dc_daily is empty")
+        return
+
+    mf["trade_date"] = mf["trade_date"].astype(int)
+
+    # Merge
+    merged = signal.merge(mf, left_on="date", right_on="trade_date", how="inner")
+    print(f"Merged days: {len(merged)} / {len(signal)} signal days")
+
+    if len(merged) < 10:
+        print("Too few overlapping days for correlation")
+        return
+
+    # 相关性检查
+    # moneyflow_dc 的主力净流入字段通常叫 buy_elg_amount - sell_elg_amount 或 net_mf_amount
+    net_col = None
+    for col in ["net_mf_amount", "buy_elg_amount", "net_mainforce_amount"]:
+        if col in merged.columns:
+            net_col = col
+            break
+    # fallback: compute from buy/sell
+    if net_col is None and "buy_lg_amount" in merged.columns:
+        merged["_net_mf"] = merged["buy_lg_amount"] - merged["sell_lg_amount"]
+        net_col = "_net_mf"
+
+    if net_col is None:
+        print(f"Available moneyflow columns: {list(merged.columns)}")
+        print("Cannot find net flow column, printing sample:")
+        print(merged.head())
+        return
+
+    # Normalize
+    merged["mf_norm"] = merged[net_col] / merged[net_col].abs().mean()
+
+    for score_col in ["score_z", "score"]:
+        if score_col not in merged.columns:
+            continue
+        clean = merged.dropna(subset=[score_col, net_col])
+        r_pearson, p_pearson = pearsonr(clean[score_col], clean[net_col])
+        r_spearman, p_spearman = spearmanr(clean[score_col], clean[net_col])
+        print(f"\n{score_col} vs {net_col}:")
+        print(f"  Pearson: r={r_pearson:.4f}, p={p_pearson:.4f}")
+        print(f"  Spearman: r={r_spearman:.4f}, p={p_spearman:.4f}")
+        print(
+            f"  Interpretation: {'同向 ✓' if r_pearson > 0 else '反向 ✗' if r_pearson < -0.1 else '弱相关'}"
+        )
+
+    # 保存合并结果
+    os.makedirs(args.output_dir, exist_ok=True)
+    out_path = os.path.join(args.output_dir, "signal_vs_moneyflow.parquet")
+    merged.to_parquet(out_path)
+    print(f"\nMerged data saved to {out_path}")
+
+
+if __name__ == "__main__":
+    main()