424 lines
16 KiB
Python
424 lines
16 KiB
Python
"""Extended factor implementations for the quant system.
|
||
|
||
This module contains additional high-quality factors that extend the default factor set.
|
||
All factors are designed to be lightweight and programmatically generated to meet
|
||
end-to-end automated decision-making requirements.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from dataclasses import dataclass
|
||
from typing import Dict, List, Sequence, Optional, Any
|
||
import functools
|
||
|
||
import numpy as np
|
||
|
||
from app.utils.logging import get_logger
|
||
|
||
LOGGER = get_logger(__name__)
|
||
LOG_EXTRA = {"stage": "extended_factors"}
|
||
|
||
|
||
def handle_factor_errors(func: Any) -> Any:
|
||
"""装饰器：处理因子计算过程中的错误
|
||
|
||
Args:
|
||
func: 要装饰的函数
|
||
|
||
Returns:
|
||
装饰后的函数
|
||
"""
|
||
@functools.wraps(func)
|
||
def wrapper(*args: Any, **kwargs: Any) -> Optional[float]:
|
||
try:
|
||
return func(*args, **kwargs)
|
||
except Exception as e:
|
||
# 获取因子名称（如果可能）
|
||
factor_name = "unknown"
|
||
if len(args) > 2 and isinstance(args[1], str):
|
||
factor_name = args[1]
|
||
elif "factor_name" in kwargs:
|
||
factor_name = kwargs["factor_name"]
|
||
|
||
LOGGER.error(
|
||
"计算因子出错 name=%s error=%s",
|
||
factor_name,
|
||
str(e),
|
||
exc_info=True,
|
||
extra=LOG_EXTRA
|
||
)
|
||
return None
|
||
return wrapper
|
||
|
||
from app.core.indicators import momentum, rolling_mean, normalize
|
||
from app.core.technical import (
|
||
rsi, macd, bollinger_bands, obv_momentum, price_volume_trend
|
||
)
|
||
from app.core.momentum import (
|
||
adaptive_momentum, momentum_quality, momentum_regime
|
||
)
|
||
from app.core.volatility import (
|
||
volatility, garch_volatility, volatility_regime,
|
||
volume_price_correlation
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class FactorSpec:
|
||
"""Specification for a factor computation.
|
||
|
||
Attributes:
|
||
name: Factor name identifier
|
||
window: Required lookback window (0 for snapshot-only factors)
|
||
"""
|
||
name: str
|
||
window: int
|
||
|
||
|
||
# Extended factors focusing on momentum, value, and liquidity signals
|
||
EXTENDED_FACTORS: List[FactorSpec] = [
|
||
# 技术分析因子
|
||
FactorSpec("tech_rsi_14", 14), # 14日RSI
|
||
FactorSpec("tech_macd_signal", 26), # MACD信号
|
||
FactorSpec("tech_bb_position", 20), # 布林带位置
|
||
FactorSpec("tech_obv_momentum", 20), # OBV动量
|
||
FactorSpec("tech_pv_trend", 20), # 价量趋势
|
||
|
||
# 趋势跟踪因子
|
||
FactorSpec("trend_ma_cross", 20), # 均线交叉信号
|
||
FactorSpec("trend_price_channel", 20), # 价格通道突破
|
||
FactorSpec("trend_adx", 14), # 平均趋向指标
|
||
|
||
# 市场微观结构因子
|
||
FactorSpec("micro_tick_direction", 5), # 逐笔方向
|
||
FactorSpec("micro_trade_imbalance", 10), # 交易失衡
|
||
|
||
# 波动率预测因子
|
||
FactorSpec("vol_garch", 20), # GARCH波动率
|
||
FactorSpec("vol_range_pred", 10), # 波动区间预测
|
||
FactorSpec("vol_regime", 20), # 波动率状态
|
||
|
||
# 量价联合因子
|
||
FactorSpec("volume_price_corr", 20), # 量价相关性
|
||
FactorSpec("volume_price_diverge", 10), # 量价背离
|
||
FactorSpec("volume_intensity", 5), # 成交强度
|
||
|
||
# 增强动量因子
|
||
FactorSpec("momentum_adaptive", 20), # 自适应动量
|
||
FactorSpec("momentum_regime", 20), # 动量区间
|
||
FactorSpec("momentum_quality", 20), # 动量质量,
|
||
|
||
# 价格均线比率因子
|
||
FactorSpec("price_ma_10_ratio", 10), # 当前价格与10日均线比率
|
||
FactorSpec("price_ma_20_ratio", 20), # 当前价格与20日均线比率
|
||
FactorSpec("price_ma_60_ratio", 60), # 当前价格与60日均线比率
|
||
|
||
# 成交量均线比率因子
|
||
FactorSpec("volume_ma_5_ratio", 5), # 当前成交量与5日均线比率
|
||
FactorSpec("volume_ma_20_ratio", 20), # 当前成交量与20日均线比率
|
||
]
|
||
|
||
|
||
class ExtendedFactors:
|
||
"""扩展因子计算实现类。
|
||
|
||
该类实现了一组用于量化交易的扩展因子计算。包括:
|
||
1. 技术分析因子 (RSI, MACD, 布林带等)
|
||
2. 趋势跟踪因子 (均线交叉等)
|
||
3. 波动率预测因子 (GARCH, 波动率状态等)
|
||
4. 量价联合因子 (量价相关性等)
|
||
5. 动量强化因子 (自适应动量等)
|
||
6. 均线比率因子 (价格/成交量均线比率)
|
||
|
||
使用示例:
|
||
calculator = ExtendedFactors()
|
||
factor_value = calculator.compute_factor(
|
||
"tech_rsi_14",
|
||
close_series,
|
||
volume_series
|
||
)
|
||
all_factors = calculator.compute_all_factors(close_series, volume_series)
|
||
normalized = calculator.normalize_factors(all_factors)
|
||
|
||
属性:
|
||
factor_specs: Dict[str, FactorSpec], 因子名称到因子规格的映射
|
||
"""
|
||
|
||
def __init__(self):
|
||
"""初始化因子计算器，构建因子规格映射"""
|
||
self.factor_specs = {spec.name: spec for spec in EXTENDED_FACTORS}
|
||
LOGGER.info(
|
||
"初始化因子计算器，加载因子数量: %d",
|
||
len(self.factor_specs),
|
||
extra=LOG_EXTRA
|
||
)
|
||
|
||
@handle_factor_errors
|
||
def compute_factor(self,
|
||
factor_name: str,
|
||
close_series: Sequence[float],
|
||
volume_series: Sequence[float]) -> Optional[float]:
|
||
"""计算单个因子值
|
||
|
||
Args:
|
||
factor_name: 因子名称，必须是已注册的因子
|
||
close_series: 收盘价序列，从新到旧排序
|
||
volume_series: 成交量序列，从新到旧排序
|
||
|
||
Returns:
|
||
factor_value: Optional[float], 计算得到的因子值，失败时返回None
|
||
|
||
Raises:
|
||
ValueError: 当因子名称未知或数据不足时抛出
|
||
"""
|
||
spec = self.factor_specs.get(factor_name)
|
||
if spec is None:
|
||
raise ValueError(f"未知的因子名称: {factor_name}")
|
||
|
||
if len(close_series) < spec.window:
|
||
raise ValueError(
|
||
f"数据长度不足: 需要{spec.window}，实际{len(close_series)}"
|
||
)
|
||
|
||
# 技术分析因子
|
||
if factor_name == "tech_rsi_14":
|
||
return rsi(close_series, 14)
|
||
|
||
elif factor_name == "tech_macd_signal":
|
||
return macd(close_series, 12, 26, 9)
|
||
|
||
elif factor_name == "tech_bb_position":
|
||
return bollinger_bands(close_series, 20)
|
||
|
||
elif factor_name == "tech_obv_momentum":
|
||
return obv_momentum(close_series, volume_series, 20)
|
||
|
||
elif factor_name == "tech_pv_trend":
|
||
return price_volume_trend(close_series, volume_series, 20)
|
||
|
||
# 趋势跟踪因子
|
||
elif factor_name == "trend_ma_cross":
|
||
ma_5 = rolling_mean(close_series, 5)
|
||
ma_20 = rolling_mean(close_series, 20)
|
||
return ma_5 - ma_20
|
||
|
||
elif factor_name == "trend_price_channel":
|
||
# 价格通道突破因子：当前价格相对于通道的位置
|
||
window = 20
|
||
high_channel = max(close_series[:window])
|
||
low_channel = min(close_series[:window])
|
||
if high_channel != low_channel:
|
||
return (close_series[0] - low_channel) / (high_channel - low_channel)
|
||
return 0.0
|
||
|
||
elif factor_name == "trend_adx":
|
||
# 简化的ADX计算：基于价格变动方向
|
||
window = 14
|
||
if len(close_series) < window + 1:
|
||
return None
|
||
|
||
# 计算价格变动
|
||
price_changes = [close_series[i] - close_series[i+1] for i in range(window)]
|
||
|
||
# 计算正向和负向变动
|
||
pos_moves = sum(max(0, change) for change in price_changes)
|
||
neg_moves = sum(max(0, -change) for change in price_changes)
|
||
|
||
# 简化的ADX计算
|
||
if pos_moves + neg_moves > 0:
|
||
return (pos_moves - neg_moves) / (pos_moves + neg_moves)
|
||
return 0.0
|
||
|
||
# 市场微观结构因子
|
||
elif factor_name == "micro_tick_direction":
|
||
# 简化的逐笔方向：基于最近价格变动
|
||
window = 5
|
||
if len(close_series) < window + 1:
|
||
return None
|
||
|
||
# 计算价格变动方向
|
||
directions = [1 if close_series[i] > close_series[i+1] else -1 for i in range(window)]
|
||
return sum(directions) / window
|
||
|
||
elif factor_name == "micro_trade_imbalance":
|
||
# 交易失衡：基于价格和成交量的联合分析
|
||
window = 10
|
||
if len(close_series) < window + 1 or len(volume_series) < window + 1:
|
||
return None
|
||
|
||
# 计算价格变动和成交量变动
|
||
price_changes = [close_series[i] - close_series[i+1] for i in range(window)]
|
||
volume_changes = [volume_series[i] - volume_series[i+1] for i in range(window)]
|
||
|
||
# 计算交易失衡指标
|
||
imbalance = sum(price_changes[i] * volume_changes[i] for i in range(window))
|
||
return imbalance / (window * np.mean(volume_series[:window]) + 1e-8)
|
||
|
||
# 波动率预测因子
|
||
elif factor_name == "vol_garch":
|
||
return garch_volatility(close_series, 20)
|
||
|
||
elif factor_name == "vol_range_pred":
|
||
# 波动区间预测：基于历史价格区间
|
||
window = 10
|
||
if len(close_series) < window + 5:
|
||
return None
|
||
|
||
# 计算历史价格区间
|
||
ranges = []
|
||
for i in range(5): # 使用最近5个窗口
|
||
if i + window < len(close_series):
|
||
price_range = max(close_series[i:i+window]) - min(close_series[i:i+window])
|
||
ranges.append(price_range / close_series[i])
|
||
|
||
if ranges:
|
||
# 使用历史区间的75分位数作为预测
|
||
return np.percentile(ranges, 75)
|
||
return None
|
||
|
||
elif factor_name == "vol_regime":
|
||
return volatility_regime(close_series, volume_series, 20)
|
||
|
||
# 量价联合因子
|
||
elif factor_name == "volume_price_corr":
|
||
return volume_price_correlation(close_series, volume_series, 20)
|
||
|
||
elif factor_name == "volume_price_diverge":
|
||
# 量价背离：价格和成交量趋势的背离程度
|
||
window = 10
|
||
if len(close_series) < window or len(volume_series) < window:
|
||
return None
|
||
|
||
# 计算价格和成交量趋势
|
||
price_trend = sum(1 if close_series[i] > close_series[i+1] else -1 for i in range(window-1))
|
||
volume_trend = sum(1 if volume_series[i] > volume_series[i+1] else -1 for i in range(window-1))
|
||
|
||
# 计算背离程度
|
||
divergence = price_trend * volume_trend * -1 # 反向为背离
|
||
return np.clip(divergence / (window - 1), -1, 1)
|
||
|
||
elif factor_name == "volume_intensity":
|
||
# 成交强度：基于成交量和价格变动的加权指标
|
||
window = 5
|
||
if len(close_series) < window + 1 or len(volume_series) < window + 1:
|
||
return None
|
||
|
||
# 计算价格变动
|
||
price_changes = [abs(close_series[i] - close_series[i+1]) for i in range(window)]
|
||
|
||
# 计算成交量加权的价格变动
|
||
weighted_changes = sum(price_changes[i] * volume_series[i] for i in range(window))
|
||
total_volume = sum(volume_series[:window])
|
||
|
||
if total_volume > 0:
|
||
intensity = weighted_changes / (total_volume * np.mean(close_series[:window]) + 1e-8)
|
||
return np.clip(intensity * 100, -100, 100) # 归一化到合理范围
|
||
return None
|
||
|
||
# 增强动量因子
|
||
elif factor_name == "momentum_adaptive":
|
||
return adaptive_momentum(close_series, volume_series, 20)
|
||
|
||
elif factor_name == "momentum_regime":
|
||
return momentum_regime(close_series, volume_series, 20)
|
||
|
||
elif factor_name == "momentum_quality":
|
||
return momentum_quality(close_series, 20)
|
||
|
||
# 均线比率因子
|
||
elif factor_name.endswith("_ratio"):
|
||
if "price_ma" in factor_name:
|
||
window = int(factor_name.split("_")[2])
|
||
ma = rolling_mean(close_series, window)
|
||
return close_series[0] / ma if ma > 0 else None
|
||
|
||
elif "volume_ma" in factor_name:
|
||
window = int(factor_name.split("_")[2])
|
||
ma = rolling_mean(volume_series, window)
|
||
return volume_series[0] / ma if ma > 0 else None
|
||
|
||
raise ValueError(f"因子 {factor_name} 没有对应的计算实现")
|
||
|
||
def compute_all_factors(self,
|
||
close_series: Sequence[float],
|
||
volume_series: Sequence[float]) -> Dict[str, float]:
|
||
"""计算所有已注册的扩展因子值
|
||
|
||
Args:
|
||
close_series: 收盘价序列，从新到旧排序
|
||
volume_series: 成交量序列，从新到旧排序
|
||
|
||
Returns:
|
||
Dict[str, float]: 因子名称到因子值的映射字典，
|
||
只包含成功计算的因子值
|
||
|
||
Note:
|
||
该方法会尝试计算所有已注册的因子，失败的因子将被忽略。
|
||
如果所有因子计算都失败，将返回空字典。
|
||
"""
|
||
results = {}
|
||
success_count = 0
|
||
total_count = len(self.factor_specs)
|
||
|
||
for factor_name in self.factor_specs:
|
||
value = self.compute_factor(factor_name, close_series, volume_series)
|
||
if value is not None:
|
||
results[factor_name] = value
|
||
success_count += 1
|
||
|
||
LOGGER.info(
|
||
"因子计算完成 total=%d success=%d failed=%d",
|
||
total_count,
|
||
success_count,
|
||
total_count - success_count,
|
||
extra=LOG_EXTRA
|
||
)
|
||
|
||
return results
|
||
|
||
def normalize_factors(self,
|
||
factors: Dict[str, float],
|
||
clip_threshold: float = 3.0) -> Dict[str, float]:
|
||
"""标准化因子值到[-1,1]区间
|
||
|
||
Args:
|
||
factors: 原始因子值字典
|
||
clip_threshold: float, 标准化时的截断阈值，默认为3.0
|
||
|
||
Returns:
|
||
Dict[str, float]: 标准化后的因子值字典，
|
||
只包含成功标准化的因子值
|
||
|
||
Note:
|
||
标准化过程包括:
|
||
1. Z-score标准化
|
||
2. 使用tanh压缩到[-1,1]区间
|
||
3. 异常值处理（截断）
|
||
"""
|
||
results = {}
|
||
success_count = 0
|
||
|
||
for name, value in factors.items():
|
||
if value is not None:
|
||
try:
|
||
normalized = normalize(value, clip_threshold)
|
||
if not np.isnan(normalized):
|
||
results[name] = normalized
|
||
success_count += 1
|
||
except Exception as e:
|
||
LOGGER.warning(
|
||
"因子标准化失败 name=%s error=%s",
|
||
name,
|
||
str(e),
|
||
extra=LOG_EXTRA
|
||
)
|
||
|
||
LOGGER.info(
|
||
"因子标准化完成 total=%d success=%d failed=%d",
|
||
len(factors),
|
||
success_count,
|
||
len(factors) - success_count,
|
||
extra=LOG_EXTRA
|
||
)
|
||
|
||
return results |