quantnodes 3.0.0__py3-none-any.whl

QuantNodes/research/factor_test/nodes/factor_score_node.py

@@ -0,0 +1,141 @@
+# coding: utf-8
+"""Node 10: 市值行业分层打分 / Factor Score Node
+
+Migrated from factor_performance.py:730-877 score_by_size_ind()
+"""
+
+
+import numpy as np
+import pandas as pd
+
+from QuantNodes.research.factor_test.nodes._base import PydanticConfigNode
+from QuantNodes.research.factor_test.nodes.configs import ScoreNodeConfig
+from QuantNodes.research.factor_test.utils.performance_metrics import evaluation, cal_net_simple
+
+
+class FactorScoreNode(PydanticConfigNode):
+    """市值行业分层打分 (3 市值组 × 29 中信行业 × N 分位)
+
+    输入: factor_neutral, mv, industry, price
+    输出: {fac_group, daily_net, eva, ...}
+    """
+
+    ConfigSchema = ScoreNodeConfig
+    _ALIASES = {
+        "_enabled": "enabled",
+        "_n_industries": "n_industries",
+        "_n_size_groups": "n_size_groups",
+        "_n_quantile_groups": "n_quantile_groups",
+    }
+
+    def _execute(self, input_data=None, **kwargs) -> dict:
+        if not self._enabled:
+            return {}
+
+        context = kwargs.get('context', {})
+        factor_data = self._factor_data(context)
+        mv = self._ctx_load(context, 'mv_float')
+        industry = self._ctx_load(context, 'id_citic1')
+        price = self._ctx_load(context, 'price')
+        factor_ori = context.get('GroupAnalyzer', {}).get('factor_direction', 1)
+
+        if factor_data is None or mv is None or industry is None or price is None:
+            raise ValueError("市值行业分层打分需要因子、市值、行业、价格数据")
+
+        return self._score_by_size_ind(factor_data, mv, industry, price, factor_ori)
+
+    def _score_by_size_ind(self, factor_data, mv, industry, price, factor_ori):
+        """市值行业分层打分"""
+        # H15: 全部可配置 (config.get 已在 __init__)
+        group = self._n_quantile_groups
+        n_size = self._n_size_groups
+        n_ind = self._n_industries
+        adj_dates = factor_data.index.tolist()
+
+        # 对齐
+        mv_adj = mv.loc[mv.index.isin(adj_dates)]
+        ind_adj = industry.loc[industry.index.isin(adj_dates)]
+        ind_adj = ind_adj.astype('int')
+
+        # 因子分组
+        fac_group = factor_data.copy() * np.nan
+        mv_group = mv.copy() * np.nan
+
+        def my_qcut(x, n):
+            if len(x.dropna().unique()) >= (n - 1):
+                return pd.qcut(x.rank(method='first'), n, labels=range(1, n + 1), duplicates='drop')
+            return x * np.nan
+
+        for i in range(len(factor_data)):
+            t_i = factor_data.index[i]
+            nonan = factor_data.loc[t_i].notna().sum()
+            # H15: 最低有效股票数 = 市值组数 × 行业数 × 分位组数
+            if nonan == 0 or nonan < n_size * n_ind * group:
+                if i > 0:
+                    fac_group.loc[t_i] = fac_group.iloc[i - 1]
+                continue
+
+            mv_group.loc[t_i] = pd.qcut(
+                mv_adj.loc[t_i], n_size, labels=range(1, n_size + 1),
+            )
+            fac_group.loc[t_i] = factor_data.loc[t_i].groupby(
+                [mv_group.loc[t_i], ind_adj.loc[t_i]]
+            ).apply(lambda x: my_qcut(x, group))
+
+        # 计算各组净值
+        price_full = price.loc[adj_dates[0]:adj_dates[-1]]
+        group_daily_ret = pd.DataFrame(np.nan, index=price_full.index, columns=range(1, group + 1))
+        group_daily_ret.iloc[0] = 0
+
+        for i in range(len(adj_dates) - 1):
+            t_i = adj_dates[i]
+            t_ii = adj_dates[i + 1]
+            if t_i not in fac_group.index:
+                continue
+            fg = fac_group.loc[t_i].dropna()
+            if fg.empty:
+                continue
+            cycle = price_full.loc[t_i:t_ii] / price_full.loc[t_i]
+            for g in range(1, group + 1):
+                stocks = fg[fg == g].index
+                valid = [s for s in stocks if s in cycle.columns]
+                if valid:
+                    gn = cycle[valid].mean(axis=1)
+                    group_daily_ret.loc[gn.index[1:], g] = gn.pct_change(fill_method=None).iloc[1:]
+
+        group_daily_net_cmp = (group_daily_ret + 1).cumprod()
+        group_daily_net_simp = group_daily_net_cmp.copy() * np.nan
+        for g in range(group):
+            group_daily_net_simp.iloc[:, g] = cal_net_simple(
+                group_daily_net_cmp.iloc[:, g], adj_dates
+            )
+
+        # 多空净值
+        if factor_ori == 1:
+            long_n, short_n = group, 1
+        else:
+            long_n, short_n = 1, group
+
+        group_daily_net_simp['longshort'] = (
+            group_daily_net_simp[long_n] - group_daily_net_simp[short_n] + 1
+        )
+
+        # 评价
+        eva = pd.DataFrame()
+        eva_yearly = {}
+        for col in group_daily_net_simp.columns:
+            eva_g = evaluation(group_daily_net_simp[col], adj_dates)
+            eva = pd.concat([eva, eva_g.iloc[0, :].to_frame()], axis=1)
+            eva_yearly[col] = eva_g.iloc[1:] if len(eva_g) > 1 else pd.DataFrame()
+
+        eva.columns = group_daily_net_simp.columns.tolist()
+        if 'Year' in eva.index:
+            eva = eva.drop('Year')
+
+        return {
+            'fac_group': fac_group,
+            'daily_net_simp': group_daily_net_simp,
+            'daily_net_cmp': group_daily_net_cmp,
+            'eva': eva,
+            'eva_yearly': eva_yearly,
+        }

QuantNodes/research/factor_test/nodes/factor_test_report_node.py

@@ -0,0 +1,153 @@
+# coding: utf-8
+"""Node 12: 汇总报告 / Factor Test Report Node
+
+Migrated from factor_output.py:539-616 save_testresult()
+Output: Parquet/JSON instead of xlwings Excel
+"""
+
+import logging
+from datetime import datetime
+
+import pandas as pd
+import numpy as np
+
+from QuantNodes.research.factor_test.nodes._base import PydanticConfigNode
+from QuantNodes.research.factor_test.nodes.configs import ReportNodeConfig
+from QuantNodes.core.path_utils import ensure_dir, resolve_path
+from pathlib import Path
+from typing import Union
+
+logger = logging.getLogger(__name__)
+
+
+class FactorTestReportNode(PydanticConfigNode):
+    """汇总所有分析结果, 输出到文件
+
+    输入: context 中所有分析结果
+    输出: FactorTestReport (dict)
+    """
+
+    ConfigSchema = ReportNodeConfig
+    _ALIASES = {"_output_format": "format"}
+
+    def __init__(self, name: str = "FactorTestReport",
+                 config: Union[dict, ReportNodeConfig, None] = None, **kwargs):
+        super().__init__(name, config, **kwargs)
+        # P-1: 路径优先级 env QUANTNODES_OUTPUT_DIR > expanduser > default
+        self._output_dir = resolve_path(self.cfg.dir, "QUANTNODES_OUTPUT_DIR")
+
+    def _execute(self, input_data=None, **kwargs) -> dict:
+        context = kwargs.get('context', {})
+
+        report = {
+            'factor_name': self._ctx_load(context, 'factor', pd.DataFrame()).columns[0]
+                if hasattr(self._ctx_load(context, 'factor', pd.DataFrame()), 'columns')
+                else 'unknown',
+            'timestamp': datetime.now().isoformat(),
+        }
+
+        # 收集各分析结果
+        if 'ICAnalyzer' in context:
+            ic = context['ICAnalyzer']
+            report['ic'] = {
+                'ic_mean': float(ic['ic_result'].get('IC均值', np.nan)),
+                'ic_std': float(ic['ic_result'].get('IC标准差', np.nan)),
+                'icir': float(ic['ic_result'].get('ICIR', np.nan)),
+                'rank_ic_mean': float(ic['rank_ic_result'].get('rankIC均值', np.nan)),
+                'rank_icir': float(ic['rank_ic_result'].get('rankICIR', np.nan)),
+            }
+
+        if 'GroupAnalyzer' in context:
+            ga = context['GroupAnalyzer']
+            report['group'] = {
+                'n_groups': ga.get('n_groups', 0),
+                'group_eva_exc': ga.get('group_eva_exc', pd.DataFrame()).to_dict()
+                    if isinstance(ga.get('group_eva_exc'), pd.DataFrame) else {},
+            }
+
+        if 'LongShort' in context:
+            ls = context['LongShort']
+            if isinstance(ls.get('eva_total'), pd.DataFrame):
+                report['longshort'] = {
+                    'eva': ls['eva_total'].to_dict(),
+                }
+
+        if 'FactorScore' in context and context['FactorScore']:
+            sc = context['FactorScore']
+            report['score'] = {
+                'eva': sc.get('eva', pd.DataFrame()).to_dict()
+                    if isinstance(sc.get('eva'), pd.DataFrame) else {},
+            }
+
+        if 'RiskCorrelation' in context:
+            rc = context['RiskCorrelation']
+            report['risk_corr'] = {
+                'mean': rc.get('mean', pd.DataFrame()).to_dict()
+                    if isinstance(rc.get('mean'), pd.DataFrame) else {},
+            }
+
+        # 输出到文件
+        self._save_report(report, context)
+
+        return report
+
+    def _save_report(self, report, context):
+        """保存报告到文件
+
+        L3 (2026-06-21): 未知 format 改为运行时 raise ValueError.
+
+            修复: 原循环中, 不在 ``{'json', 'parquet'}`` 内的 fmt 会被
+            静默 skip — 用户写 ``format=['html']`` 不报错, 也不生成文件,
+            易被误判为"配置没生效". 修复后, 未知 fmt 显式 raise, 错误信息
+            列出所有合法值.
+
+        Raises:
+            ValueError: ``fmt`` 不在 ``{'json', 'parquet'}`` 内.
+        """
+        output_dir = Path(self._output_dir)
+        ensure_dir(output_dir)
+
+        factor_name = report.get('factor_name', 'factor')
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+
+        for fmt in self._output_format:
+            if fmt == 'json':
+                import json
+                # 转换不可序列化的对象
+                def default_serializer(obj):
+                    if isinstance(obj, (pd.Series, pd.DataFrame)):
+                        return obj.to_dict()
+                    if isinstance(obj, np.integer):
+                        return int(obj)
+                    if isinstance(obj, np.floating):
+                        return float(obj)
+                    if isinstance(obj, np.ndarray):
+                        return obj.tolist()
+                    return str(obj)
+
+                path = output_dir / f"factor_test_{factor_name}_{timestamp}.json"
+                with open(path, 'w', encoding='utf-8') as f:
+                    json.dump(report, f, ensure_ascii=False, indent=2, default=default_serializer)
+                logger.info(f"报告已保存: {path}")
+
+            elif fmt == 'parquet':
+                # 保存各分析结果为 parquet
+                for key, value in context.items():
+                    if key.startswith('_'):
+                        continue
+                    if isinstance(value, dict):
+                        for sub_key, sub_val in value.items():
+                            if isinstance(sub_val, pd.DataFrame) and not sub_val.empty:
+                                path = output_dir / f"{factor_name}_{key}_{sub_key}.parquet"
+                                sub_val.to_parquet(path)
+                    elif isinstance(value, pd.DataFrame) and not value.empty:
+                        path = output_dir / f"{factor_name}_{key}.parquet"
+                        value.to_parquet(path)
+                logger.info(f"Parquet 文件已保存至: {output_dir}")
+
+            else:
+                # L3 (2026-06-21): 未知 format 显式 raise (修复 silent skip).
+                raise ValueError(
+                    f"FactorTestReport 不支持的 format: {fmt!r}, "
+                    f"仅支持 'json' / 'parquet'"
+                )

QuantNodes/research/factor_test/nodes/group_analyzer_node.py

@@ -0,0 +1,317 @@
+# coding: utf-8
+"""Node 8: 分组分析 / Group Analyzer Node
+
+Migrated from factor_performance.py:361-560 cal_group_ret()
+"""
+
+
+import logging
+from typing import Literal
+
+import numpy as np
+import pandas as pd
+
+from QuantNodes.research.factor_test.nodes._base import PydanticConfigNode
+from QuantNodes.research.factor_test.nodes.configs import GroupAnalyzerNodeConfig
+from QuantNodes.research.factor_test.utils.performance_metrics import (
+    evaluation, cal_net_simple
+)
+from QuantNodes.research.factor_test.utils.constants import INDEX_CP_MAPPING
+
+logger = logging.getLogger(__name__)
+
+
+FactorKind = Literal["ranked", "discrete"]
+
+
+def _classify_factor(row: pd.Series, n_groups: int) -> FactorKind:
+    """按 dtype + n_unique 判别因子分桶策略。
+
+    Returns:
+        "discrete" — bool dtype, 或 n_unique <= 2（捕获 float-cast 二值）
+        "ranked"   — 其余（连续或轻度 ties, 走 rank('first') + qcut）
+
+    注: n_unique >= 3 的整数 dtype 因子走 ranked 分支, 因为
+    _group_discrete 按 value 比例分配组段, 对 n_unique > n_groups 的
+    输入无法产出恰好 n_groups 个组 (会产生 n_unique 个组)。
+    """
+    n_unique = row.nunique()
+    if pd.api.types.is_bool_dtype(row):
+        return "discrete"
+    if n_unique <= 2:
+        return "discrete"
+    return "ranked"
+
+
+def _group_ranked(series: pd.Series, n_groups: int) -> pd.Series:
+    """通用 rank('first') + qcut: 处理连续和轻度 ties 因子。
+
+    修复 pd.qcut(duplicates='drop') 在 ties 下抛 "Bin labels must be
+    one fewer than the number of bin edges" 的 bug (alpha-004 等场景:
+    7 unique × 50 行有大量 ties)。
+
+    对无 ties 的纯连续因子, rank('first') 产出 1..n 唯一序号,
+    qcut 在序号上的分位点与原 qcut(series) 上的分位点对应同一组
+    元素 (单调变换保序), 行为 bitwise 等价 (零回归)。
+    """
+    return pd.qcut(
+        series.rank(method='first'),
+        n_groups,
+        labels=range(1, n_groups + 1),
+        duplicates='drop'
+    )
+
+
+def _group_discrete(
+    series: pd.Series, n_groups: int, date_int: int
+) -> pd.Series:
+    """bool / 离散因子 (n_unique <= 2): 按 value 比例分配组段 + 内部 seeded shuffle。
+
+    算法:
+      1. sorted unique values, 按 count/len*n_groups 比例 round 分配组数
+      2. 最后一个 value 用减法 (n_groups - sum(prev)) 强制补齐, 避免累计漂移
+      3. np.random.seed(date_int % 2**31) 每日同 seed → 可复现
+      4. value 内部 shuffle 后用整数除法 j * n_g // n_v 均分到所属组段
+
+    Args:
+        series: 单日 50 只股票的 factor values (dropna 后)
+        n_groups: 总组数 (默认 5)
+        date_int: yyyymmdd 整数, 用作 shuffle seed
+
+    Returns:
+        pd.Series: index=series.index, values ∈ {1, ..., n_groups}
+    """
+    unique_vals = sorted(series.unique())
+    n_total = len(series)
+    counts = {v: int((series == v).sum()) for v in unique_vals}
+
+    n_g_list: list[int] = []
+    for v in unique_vals[:-1]:
+        n_g_list.append(max(1, round(counts[v] / n_total * n_groups)))
+    n_g_list.append(max(1, n_groups - sum(n_g_list)))
+
+    starts: list[int] = [1]
+    for ng in n_g_list[:-1]:
+        starts.append(starts[-1] + ng)
+
+    np.random.seed(int(date_int) % (2**31))
+    groups = pd.Series(np.nan, index=series.index)
+    for v, ng, g_start in zip(unique_vals, n_g_list, starts):
+        if ng <= 0:
+            continue
+        val_idx = list(series[series == v].index)
+        np.random.shuffle(val_idx)
+        n_v = len(val_idx)
+        for j, idx in enumerate(val_idx):
+            g_within = min(ng - 1, j * ng // n_v) if n_v > 0 else 0
+            groups[idx] = g_start + g_within
+    return groups
+
+
+class GroupAnalyzerNode(PydanticConfigNode):
+    """N 分位分组 + 各组收益/净值/评价
+
+    输入: factor_neutral, price, index_cp
+    输出: {fac_group, group_num, group_ret, daily_net_simp, daily_excnet_simp,
+            group_eva_abs, group_eva_exc, turnover, ...}
+    """
+
+    ConfigSchema = GroupAnalyzerNodeConfig
+    _ALIASES = {
+        "_groups": "groups",
+        "_factor_direction": "factor_direction",
+        "_floor_mode": "floor_mode",
+        "_hedge": "hedge",
+        "_hedge_path": "hedge_path",
+    }
+
+    def _execute(self, input_data=None, **kwargs) -> dict:
+        context = kwargs.get('context', {})
+        factor_data = self._factor_data(context)
+        price = self._ctx_load(context, 'price')
+        index_cp = self._ctx_load(context, 'index_cp')
+
+        if factor_data is None or price is None:
+            raise ValueError("因子或价格数据缺失")
+
+        return self._calc_group_return(
+            factor_data, price, index_cp,
+            self._groups, self._factor_direction,
+            self._floor_mode, self._hedge, self._hedge_path
+        )
+
+    def _calc_group_return(self, factor_data, price, index_cp,
+                           group, factor_ori, floor_mode, hedge, hedge_path):
+        """计算分组收益"""
+        adj_dates = factor_data.index.tolist()
+        n_groups = group
+
+        # 分组标签
+        fac_group = factor_data.copy() * np.nan
+        for i in range(len(factor_data)):
+            t_i = factor_data.index[i]
+            row = factor_data.loc[t_i].dropna()
+            nonan = len(row)
+            if nonan == 0 or nonan < group:
+                if floor_mode == 'group' or i == 0:
+                    continue
+                elif floor_mode == 'last':
+                    fac_group.loc[t_i] = fac_group.iloc[i - 1]
+                    continue
+
+            kind = _classify_factor(row, group)
+            if kind == "discrete":
+                fac_group.loc[t_i] = _group_discrete(row, group, int(t_i))
+            else:
+                fac_group.loc[t_i] = _group_ranked(row, group)
+
+        # 各期每组收益
+        price_adj = price.loc[price.index.isin(adj_dates)]
+        stock_cycle_ret = price_adj.pct_change(fill_method=None).shift(-1)
+
+        group_num = pd.DataFrame(np.nan, index=adj_dates, columns=range(1, n_groups + 1))
+        group_ret = group_num.copy()
+        group_winratio = group_num.copy()
+        group_winloss = group_num.copy()
+
+        for t_i in adj_dates[:-1]:
+            if t_i not in fac_group.index or t_i not in stock_cycle_ret.index:
+                continue
+            fg = fac_group.loc[t_i].dropna()
+            if fg.empty:
+                continue
+            ret_i = stock_cycle_ret.loc[t_i]
+            temp = ret_i.groupby(fg).agg(['count', 'mean'])
+            for g in range(1, n_groups + 1):
+                if g in temp.index:
+                    group_num.loc[t_i, g] = temp.loc[g, 'count']
+                    group_ret.loc[t_i, g] = temp.loc[g, 'mean']
+                    mask = fg[fg == g].index
+                    vals = ret_i.reindex(mask).dropna()
+                    if len(vals) > 0:
+                        group_winratio.loc[t_i, g] = (vals > 0).mean()
+                        pos = vals[vals > 0].mean()
+                        neg = vals[vals < 0].mean()
+                        has_valid_neg = pd.notna(neg) and neg != 0
+                        group_winloss.loc[t_i, g] = pos / neg * -1 if has_valid_neg else np.nan
+
+        # 各组日度净值 (单利)
+        price_full = price.loc[adj_dates[0]:adj_dates[-1]]
+        group_daily_ret = pd.DataFrame(
+            np.nan, index=price_full.index, columns=range(1, n_groups + 1)
+        )
+        group_daily_ret.iloc[0] = 0
+
+        for i in range(len(adj_dates) - 1):
+            t_i = adj_dates[i]
+            t_ii = adj_dates[i + 1]
+            if t_i not in fac_group.index:
+                continue
+            fg = fac_group.loc[t_i].dropna()
+            if fg.empty:
+                continue
+            cycle_net = price_full.loc[t_i:t_ii] / price_full.loc[t_i]
+            # 向量化：一次 groupby 替代内层 for g 循环 (6x 提速)
+            group_mean = cycle_net.T.groupby(fg).mean().T
+            group_pct = group_mean.pct_change(fill_method=None).iloc[1:]
+            group_daily_ret.loc[group_pct.index] = group_pct.values
+
+        group_daily_net_cmp = (group_daily_ret + 1).cumprod()
+        group_daily_net_simp = group_daily_net_cmp.copy() * np.nan
+        for g in range(n_groups):
+            group_daily_net_simp.iloc[:, g] = cal_net_simple(
+                group_daily_net_cmp.iloc[:, g], adj_dates
+            )
+
+        # 对冲基准
+        benchmark = self._get_benchmark(hedge, hedge_path, index_cp, price_full,
+                                        factor_data, adj_dates)
+        if benchmark is not None:
+            benchmark_cmp = benchmark / benchmark.iloc[0]
+            benchmark_simp = cal_net_simple(benchmark_cmp, adj_dates)
+
+            # 超额净值
+            group_daily_excnet_simp = group_daily_net_simp.sub(benchmark_simp.values, axis=0) + 1
+            group_daily_excnet_cmp = group_daily_net_cmp.sub(benchmark_cmp.values, axis=0) + 1
+        else:
+            group_daily_excnet_simp = group_daily_net_simp.copy()
+            group_daily_excnet_cmp = group_daily_net_cmp.copy()
+
+        # 评价
+        group_eva_abs = pd.DataFrame()
+        group_eva_exc = pd.DataFrame()
+        group_eva_abs_yearly = {}
+        group_eva_exc_yearly = {}
+
+        for g in range(1, n_groups + 1):
+            # 换手率
+            turn = ((fac_group == g) & (fac_group.diff(-1) != 0)).sum(axis=1) / (
+                (fac_group == g).sum(axis=1) * 2
+            )
+            turn.name = g
+
+            result_g = evaluation(group_daily_net_simp[g], adj_dates)
+            result_exc_g = evaluation(group_daily_excnet_simp[g], adj_dates)
+
+            group_eva_abs = pd.concat([group_eva_abs, result_g.iloc[0, 1:].to_frame()], axis=1)
+            group_eva_exc = pd.concat([group_eva_exc, result_exc_g.iloc[0, 1:].to_frame()], axis=1)
+            group_eva_abs_yearly[g] = result_g.iloc[1:]
+            group_eva_exc_yearly[g] = result_exc_g.iloc[1:]
+
+        group_eva_abs.columns = range(1, n_groups + 1)
+        group_eva_exc.columns = range(1, n_groups + 1)
+
+        return {
+            'adjust_dates': adj_dates,
+            'fac_group': fac_group,
+            'group_num': group_num,
+            'group_ret': group_ret,
+            'group_winratio': group_winratio,
+            'group_winloss': group_winloss,
+            'daily_net_simp': group_daily_net_simp,
+            'daily_net_cmp': group_daily_net_cmp,
+            'daily_excnet_simp': group_daily_excnet_simp,
+            'daily_excnet_cmp': group_daily_excnet_cmp,
+            'group_eva_abs': group_eva_abs,
+            'group_eva_exc': group_eva_exc,
+            'group_eva_abs_yearly': group_eva_abs_yearly,
+            'group_eva_exc_yearly': group_eva_exc_yearly,
+            'turnover': pd.DataFrame() if 'turn' not in dir() else turn,
+            'n_groups': n_groups,
+        }
+
+    def _get_benchmark(self, hedge, hedge_path, index_cp, price_full, factor_data, adj_dates):
+        """获取对冲基准净值"""
+        if hedge == 'equal':
+            # 等权基准: 所有有因子值的股票收益等权
+            benchmark = pd.Series(np.nan, index=price_full.index)
+            benchmark.iloc[0] = 0
+            for i in range(len(adj_dates) - 1):
+                t_i = adj_dates[i]
+                t_ii = adj_dates[i + 1]
+                if t_i not in factor_data.index:
+                    continue
+                stocks_with_factor = factor_data.loc[t_i].dropna().index
+                cycle = price_full.loc[t_i:t_ii] / price_full.loc[t_i]
+                valid = [s for s in stocks_with_factor if s in cycle.columns]
+                if valid:
+                    benchmark.loc[cycle.index[1:]] = (
+                        cycle[valid].mean(axis=1).pct_change(fill_method=None).iloc[1:]
+                    )
+            return (benchmark + 1).cumprod()
+
+        elif hedge in INDEX_CP_MAPPING and index_cp is not None:
+            key = INDEX_CP_MAPPING[hedge]
+            if key in index_cp.columns:
+                return index_cp.loc[price_full.index, key]
+
+        elif hedge == 'custom' and hedge_path:
+            try:
+                from QuantNodes.research.factor_test.utils.data_loader import DataLoader
+                loader = DataLoader()
+                custom = loader.load_custom(('', hedge_path))
+                return custom.iloc[:, 0]
+            except Exception as e:
+                logger.warning("GroupAnalyzerNode: 自定义对冲加载失败 (%s): %s", hedge_path, e)
+
+        return None