From f438c6cd652929abde76494ac558480030893cb3 Mon Sep 17 00:00:00 2001
From: claude_dev <claude-dev@sanguo.local>
Date: Tue, 25 Aug 2026 10:29:43 +0800
Subject: [PATCH] =?UTF-8?q?perf(factor):=20metrics=E7=83=AD=E8=B7=AF?=
 =?UTF-8?q?=E5=BE=84numpy/scipy=E5=8C=96=E2=80=94=E2=80=94rank=5Fcorr/quan?=
 =?UTF-8?q?tile=5Fmask/decile=E7=9A=84pandas=20rank=E6=94=B9scipy=20rankda?=
 =?UTF-8?q?ta(axis=3D1)C=E5=AE=9E=E7=8E=B0,=E5=AE=BD=E7=9F=A9=E9=98=B5?=
 =?UTF-8?q?=E5=8E=8B=E5=8A=9B=E4=B8=8B=E5=88=86=E9=92=9F=E7=BA=A7=E2=86=92?=
 =?UTF-8?q?=E7=A7=92=E7=BA=A7;=E6=8E=A5=E5=8F=A3=E4=B8=8E=E6=95=B0?=
 =?UTF-8?q?=E5=80=BC=E4=B8=8D=E5=8F=98,=E6=B5=8B=E8=AF=95=E5=8E=9F?=
 =?UTF-8?q?=E6=A0=B7=E5=85=A8=E7=BB=BF+=E9=80=9F=E5=BA=A6=E6=8A=A4?=
 =?UTF-8?q?=E6=A0=8F=20[vps]?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 sanguo_factor/metrics.py     | 81 ++++++++++++++++++++++++++++++++----
 tests/factor/test_metrics.py | 10 +++++
 2 files changed, 83 insertions(+), 8 deletions(-)

diff --git a/sanguo_factor/metrics.py b/sanguo_factor/metrics.py
index f41ec19..f427a4b 100644
--- a/sanguo_factor/metrics.py
+++ b/sanguo_factor/metrics.py
@@ -8,6 +8,7 @@ import warnings
 
 import numpy as np
 import pandas as pd
+from scipy import stats
 
 TRADING_DAYS_PER_YEAR = 244
 
@@ -35,8 +36,27 @@ def rank_corr_rows(A: pd.DataFrame, B: pd.DataFrame) -> pd.Series:
     """逐日 Spearman:先各自按行取秩再逐行 Pearson."""
     cols = A.columns.intersection(B.columns)
     idx = A.index.intersection(B.index)
-    a = A.loc[idx, cols].rank(axis=1).to_numpy(dtype=float)
-    b = B.loc[idx, cols].rank(axis=1).to_numpy(dtype=float)
+    a_vals = A.loc[idx, cols].to_numpy(dtype=float)
+    b_vals = B.loc[idx, cols].to_numpy(dtype=float)
+
+    # scipy.stats.rankdata ranks NaN positions (NaN sorts last)
+    # pandas keeps NaN as NaN, so we need to mask and restore
+    a_nan = np.isnan(a_vals)
+    b_nan = np.isnan(b_vals)
+
+    # Fill NaN with large negative value (sorts first, then rankdata puts it last)
+    # But we need it to sort last, so use large positive
+    a_filled = np.where(a_nan, np.inf, a_vals)
+    b_filled = np.where(b_nan, np.inf, b_vals)
+
+    # scipy.stats.rankdata with axis=1 ranks per row
+    a = stats.rankdata(a_filled, axis=1)
+    b = stats.rankdata(b_filled, axis=1)
+
+    # Restore NaN at original NaN positions
+    a[a_nan] = np.nan
+    b[b_nan] = np.nan
+
     return _row_pearson(a, b, idx)
 
 
@@ -53,12 +73,43 @@ def factor_turnover(F: pd.DataFrame) -> float:
 
 def _quantile_mask(F: pd.DataFrame, top: bool) -> pd.DataFrame:
     """按行把因子值分位选mask(基于升序秩/当日有效数). top=True选最大10%,False选最小10%."""
-    ranks = F.rank(axis=1, ascending=False)  # 1=最大
-    n = ranks.notna().sum(axis=1)
-    k = np.maximum((n * 0.1).round().astype(int), 1)
+    vals = F.to_numpy(dtype=float)
+    nan_mask = np.isnan(vals)
+
+    # For descending rank (1=max), rank negative values
+    # scipy.stats.rankdata sorts ascending by default
+    vals_filled = np.where(nan_mask, -np.inf, -vals)  # NaN -> -inf (smallest), negate for descending
+    ranks = stats.rankdata(vals_filled, axis=1)
+
+    # Now ranks are in descending order (1=max), but NaN got rank 1, need to shift
+    # Actually, let me think more carefully:
+    # - pandas rank(axis=1, ascending=False): 1 = max, NaN = NaN
+    # - scipy rankdata on negative values: smallest original gets largest rank
+    # - So -val (largest original) -> smallest rank value = 1
+    # This is what we want!
+
+    # But NaN got filled with -inf, which becomes largest, so rank is 1 - wrong!
+    # Need to fill NaN with something that becomes largest rank
+    vals_filled = np.where(nan_mask, np.inf, -vals)  # NaN -> +inf (largest after negation)
+    ranks = stats.rankdata(vals_filled, axis=1)
+
+    # Now: max original -> -max -> min rank = 1 ✓
+    # NaN -> +inf -> max rank (last) ✓
+
+    # Restore NaN at original NaN positions
+    ranks[nan_mask] = np.nan
+
+    n = (~nan_mask).sum(axis=1)
+    k = np.maximum((n * 0.1).round().astype(int), 1).reshape(-1, 1)
+
     if top:
-        return ranks.le(k, axis=0) & ranks.notna()
-    return ranks.ge(n - k + 1, axis=0) & ranks.notna()
+        mask = (ranks <= k) & ~nan_mask
+    else:
+        # For bottom: n - k + 1 to n
+        # E.g., n=10, k=1: ranks 10 to 10 (last 1)
+        mask = (ranks >= n.reshape(-1, 1) - k + 1) & ~nan_mask
+
+    return pd.DataFrame(mask, index=F.index, columns=F.columns)
 
 
 def long_short_annual_return(F: pd.DataFrame, R: pd.DataFrame) -> float | None:
@@ -79,7 +130,21 @@ def decile_annual_returns(F: pd.DataFrame, R: pd.DataFrame) -> list[float | None
     cols = F.columns.intersection(R.columns)
     idx = F.index.intersection(R.index)
     f, r = F.loc[idx, cols], R.loc[idx, cols]
-    pct = f.rank(axis=1, ascending=True).div(f.notna().sum(axis=1), axis=0)
+
+    vals = f.to_numpy(dtype=float)
+    nan_mask = np.isnan(vals)
+
+    # Fill NaN with large value (sorts last, gets largest rank)
+    vals_filled = np.where(nan_mask, np.inf, vals)
+    ranks = stats.rankdata(vals_filled, axis=1)
+
+    # Restore NaN at original positions
+    ranks[nan_mask] = np.nan
+
+    # Normalize to percentiles
+    n = (~nan_mask).sum(axis=1, keepdims=True)
+    pct = ranks / n
+
     out: list[float | None] = []
     for d in range(10):
         sel = (pct > d / 10) & (pct <= (d + 1) / 10)
diff --git a/tests/factor/test_metrics.py b/tests/factor/test_metrics.py
index 93e2fdd..251c6d5 100644
--- a/tests/factor/test_metrics.py
+++ b/tests/factor/test_metrics.py
@@ -99,3 +99,13 @@ def test_summarize_factor_structure():
         assert key in p1
     assert p1["count"] == 60
     assert p1["ic_mean"] < 0  # 构造为负相关
+
+
+def test_rank_corr_rows_speed_guard():
+    import time
+    rng = np.random.default_rng(1)
+    F = pd.DataFrame(rng.normal(size=(2000, 100)))
+    R = pd.DataFrame(rng.normal(size=(2000, 100)))
+    t0 = time.time()
+    rank_corr_rows(F, R)
+    assert time.time() - t0 < 3