cfdaily
597 lines
23 KiB
Python
597 lines
23 KiB
Python
"""
|
||
结构化适配动态多因子策略
|
||
完整方案：
|
||
1. 因子池: 价值20% + 质量20% + 成长15% + 中国特色25% + 技术趋势10% + 板块强度10%
|
||
2. 因子预处理: 行业中性 + 市值中性 + zscore标准化
|
||
3. 动态加权: 每月更新IC，IC越高权重越高
|
||
4. 选股: top20-30，只保留站上年线的
|
||
5. 仓位: 估值择时定总仓位，单票不超5%，单板块不超20%
|
||
"""
|
||
import pandas as pd
|
||
import numpy as np
|
||
from typing import Dict, List, Optional
|
||
|
||
from vnpy.trader.app.ctaStrategy import CtaTemplate
|
||
from vnpy.trader.object import BarData
|
||
|
||
# 导入因子和工具
|
||
import sys
|
||
sys.path.append('.')
|
||
from factors import (
|
||
PEFactor, PBFactor,
|
||
ROEFactor,
|
||
RevenueGrowthFactor, ProfitGrowthFactor,
|
||
SizeFactor, ReversalFactor,
|
||
Momentum1MFactor, Momentum3MFactor,
|
||
SectorStrengthFactor
|
||
)
|
||
from utils import (
|
||
batch_process_factors,
|
||
prepare_market_cap_neutral,
|
||
DynamicICWeightAdjuster,
|
||
MarketValuationTiming
|
||
)
|
||
from data import (
|
||
FactorDataProcessor,
|
||
SectorStrengthEngine
|
||
)
|
||
from strategies import (
|
||
TechnicalTimingSignals,
|
||
MarketRegimeWeightAllocator
|
||
)
|
||
|
||
|
||
class StructuredDynamicMultiFactorStrategy(CtaTemplate):
|
||
"""
|
||
结构化适配动态多因子策略
|
||
适配当前A股结构化板块轮动行情
|
||
"""
|
||
|
||
# 策略参数 - 全部开放配置，方便参数遍历优化
|
||
author = "翼德"
|
||
parameters = [
|
||
# 调仓设置
|
||
"rebalance_freq", # 调仓频率: 'M'月频, 'W'周频
|
||
"top_n", # 选股数量
|
||
# 过滤条件
|
||
"require_above_ma", # 是否要求站上年线
|
||
"ma_period", # 年线周期
|
||
# 因子权重（初始权重，动态加权会更新）
|
||
"value_weight", # 价值因子权重（PE+PB）
|
||
"quality_weight", # 质量因子权重（ROE）
|
||
"growth_weight", # 成长因子权重（增速）
|
||
"china_special_weight", # 中国特色权重（市值+反转）
|
||
"trend_weight", # 趋势因子权重（动量）
|
||
"sector_strength_weight", # 板块强度权重
|
||
# 板块强度计算权重
|
||
"sector_tech_weight", # 板块强度技术面权重
|
||
"sector_fund_weight", # 板块强度资金面权重
|
||
"sector_basic_weight", # 板块强度基本面权重
|
||
"sector_sentiment_weight", # 板块强度情绪面权重
|
||
# 仓位限制
|
||
"max_single_pct", # 单票最大仓位占比
|
||
"max_sector_pct", # 单板块最大仓位占比（相对于总仓位）
|
||
# 动态加权设置
|
||
"dynamic_weight_enabled", # 是否开启动态加权
|
||
"ic_window", # IC滚动窗口月数
|
||
# 市场状态权重
|
||
"regime_weight_enabled", # 是否开启牛熊市不同权重分配
|
||
# 估值择时设置
|
||
"market_timing_enabled", # 是否开启估值择时
|
||
"min_total_position", # 最小总仓位
|
||
"max_total_position", # 最大总仓位
|
||
# 技术择时过滤
|
||
"tech_filter_enabled", # 是否开启技术择时二次过滤
|
||
"min_bullish_score", # 最小看多得分才能入选
|
||
]
|
||
|
||
# 策略变量
|
||
variables = [
|
||
"current_weights", # 当前因子权重
|
||
"target_total_position", # 当前目标总仓位
|
||
"last_rebalance_date", # 上次调仓日期
|
||
"current_ic", # 当前各因子IC
|
||
]
|
||
|
||
def __init__(self, cta_engine, strategy_name, setting_dict):
|
||
super().__init__(cta_engine, strategy_name, setting_dict)
|
||
|
||
# ========== 默认参数 ==========
|
||
# 调仓设置
|
||
self.rebalance_freq = getattr(self, 'rebalance_freq', 'M')
|
||
self.top_n = getattr(self, 'top_n', 25)
|
||
|
||
# 过滤条件
|
||
self.require_above_ma = getattr(self, 'require_above_ma', True)
|
||
self.ma_period = getattr(self, 'ma_period', 250)
|
||
|
||
# 因子初始权重
|
||
self.value_weight = getattr(self, 'value_weight', 0.20)
|
||
self.quality_weight = getattr(self, 'quality_weight', 0.20)
|
||
self.growth_weight = getattr(self, 'growth_weight', 0.15)
|
||
self.china_special_weight = getattr(self, 'china_special_weight', 0.25)
|
||
self.trend_weight = getattr(self, 'trend_weight', 0.10)
|
||
self.sector_strength_weight = getattr(self, 'sector_strength_weight', 0.10)
|
||
|
||
# 板块强度计算权重
|
||
self.sector_tech_weight = getattr(self, 'sector_tech_weight', 0.40)
|
||
self.sector_fund_weight = getattr(self, 'sector_fund_weight', 0.30)
|
||
self.sector_basic_weight = getattr(self, 'sector_basic_weight', 0.20)
|
||
self.sector_sentiment_weight = getattr(self, 'sector_sentiment_weight', 0.10)
|
||
|
||
# 仓位限制
|
||
self.max_single_pct = getattr(self, 'max_single_pct', 0.05)
|
||
self.max_sector_pct = getattr(self, 'max_sector_pct', 0.20)
|
||
|
||
# 动态加权
|
||
self.dynamic_weight_enabled = getattr(self, 'dynamic_weight_enabled', True)
|
||
self.ic_window = getattr(self, 'ic_window', 12)
|
||
|
||
# 市场状态权重
|
||
self.regime_weight_enabled = getattr(self, 'regime_weight_enabled', True)
|
||
|
||
# 估值择时
|
||
self.market_timing_enabled = getattr(self, 'market_timing_enabled', True)
|
||
self.min_total_position = getattr(self, 'min_total_position', 0.3)
|
||
self.max_total_position = getattr(self, 'max_total_position', 1.0)
|
||
|
||
# 技术择时二次过滤
|
||
self.tech_filter_enabled = getattr(self, 'tech_filter_enabled', True)
|
||
self.min_bullish_score = getattr(self, 'min_bullish_score', 0.4)
|
||
|
||
# ========== 初始化因子 ==========
|
||
self.factors = self._init_factors()
|
||
|
||
# ========== 初始化板块强度引擎 ==========
|
||
self.sector_strength_engine = SectorStrengthEngine(
|
||
weight_tech=self.sector_tech_weight,
|
||
weight_fund=self.sector_fund_weight,
|
||
weight_basic=self.sector_basic_weight,
|
||
weight_sentiment=self.sector_sentiment_weight
|
||
)
|
||
|
||
# ========== 初始化技术择时 ==========
|
||
self.tech_timing = TechnicalTimingSignals()
|
||
|
||
# ========== 初始化市场状态权重 ==========
|
||
if self.regime_weight_enabled:
|
||
self.regime_allocator = MarketRegimeWeightAllocator()
|
||
# 根据当前市场状态获取权重
|
||
index_data = self.get_market_index_data()
|
||
if index_data is not None:
|
||
default_weights = self.regime_allocator.expand_to_factor_names(
|
||
self.regime_allocator.get_weights(index_data)
|
||
)
|
||
else:
|
||
# 默认震荡市权重
|
||
default_weights = self.regime_allocator.expand_to_factor_names(
|
||
self.regime_allocator.weights['range_bound']
|
||
)
|
||
else:
|
||
# 固定权重按配置比例分配
|
||
# 价值类两个因子平分value_weight
|
||
# 成长类两个因子平分growth_weight
|
||
# 中国特色两个因子平分china_special_weight
|
||
# 趋势两个因子平分trend_weight
|
||
default_weights = {
|
||
'pe': self.value_weight * 0.5,
|
||
'pb': self.value_weight * 0.5,
|
||
'roe': self.quality_weight,
|
||
'revenue_growth': self.growth_weight * 0.5,
|
||
'profit_growth': self.growth_weight * 0.5,
|
||
'size': self.china_special_weight * 0.5,
|
||
'reversal_1m': self.china_special_weight * 0.5,
|
||
'momentum_1m': self.trend_weight * 0.3,
|
||
'momentum_3m': self.trend_weight * 0.7,
|
||
'sector_strength': self.sector_strength_weight,
|
||
}
|
||
|
||
# 因子字典 {名称: 实例}
|
||
self.factor_dict = {f.name: f for f in self.factors}
|
||
|
||
# ========== 初始化动态加权 ==========
|
||
if self.dynamic_weight_enabled:
|
||
factor_names = list(self.factor_dict.keys())
|
||
self.ic_adjuster = DynamicICWeightAdjuster(
|
||
factor_names,
|
||
window_size=self.ic_window
|
||
)
|
||
|
||
# ========== 初始化估值择时 ==========
|
||
if self.market_timing_enabled:
|
||
self.market_timer = MarketValuationTiming(
|
||
min_position=self.min_total_position,
|
||
max_position=self.max_total_position
|
||
)
|
||
self.target_total_position = self.max_total_position
|
||
else:
|
||
self.target_total_position = self.max_total_position
|
||
|
||
# 状态变量
|
||
self.current_weights = default_weights
|
||
self.last_rebalance_date = None
|
||
self.current_ic = None
|
||
self.last_data = None # 保存上期数据用于IC计算
|
||
|
||
def _init_factors(self):
|
||
"""初始化所有因子实例"""
|
||
factors = [
|
||
PEFactor(),
|
||
PBFactor(),
|
||
ROEFactor(),
|
||
RevenueGrowthFactor(),
|
||
ProfitGrowthFactor(),
|
||
SizeFactor(),
|
||
ReversalFactor(),
|
||
Momentum1MFactor(),
|
||
Momentum3MFactor(),
|
||
SectorStrengthFactor(),
|
||
]
|
||
return factors
|
||
|
||
def on_init(self):
|
||
"""策略初始化"""
|
||
self.write_log(
|
||
f"结构化动态多因子初始化完成: "
|
||
f"选股{self.top_n}只，单票{self.max_single_pct*100:.0f}%，"
|
||
f"单板块{self.max_sector_pct*100:.0f}%，"
|
||
f"动态加权={'开' if self.dynamic_weight_enabled else '关'}，"
|
||
f"估值择时={'开' if self.market_timing_enabled else '关'}"
|
||
)
|
||
# 加载足够数据
|
||
required_bars = max(self.ma_period, 252)
|
||
self.load_bar(required_bars)
|
||
|
||
def on_start(self):
|
||
self.write_log("策略启动")
|
||
|
||
def on_stop(self):
|
||
self.write_log("策略停止")
|
||
|
||
def on_bar(self, bar: BarData):
|
||
"""K线推送，判断调仓"""
|
||
current_date = bar.datetime.date()
|
||
|
||
if not self._need_rebalance(current_date):
|
||
return
|
||
|
||
self.rebalance(current_date)
|
||
self.last_rebalance_date = current_date
|
||
|
||
def _need_rebalance(self, current_date) -> bool:
|
||
"""判断是否需要调仓"""
|
||
if self.last_rebalance_date is None:
|
||
return True
|
||
|
||
if self.rebalance_freq == 'M':
|
||
# 不同月份调仓
|
||
if current_date.month != self.last_rebalance_date.month:
|
||
return True
|
||
elif self.rebalance_freq == 'W':
|
||
# 不同周调仓
|
||
curr_week = current_date.isocalendar()[1]
|
||
last_week = self.last_rebalance_date.isocalendar()[1]
|
||
if curr_week != last_week:
|
||
return True
|
||
|
||
return False
|
||
|
||
def _filter_above_ma(self, candidate_symbols: List[str], data: pd.DataFrame) -> List[str]:
|
||
"""过滤出站上年线的股票"""
|
||
if not self.require_above_ma:
|
||
return candidate_symbols
|
||
|
||
filtered = []
|
||
for symbol in candidate_symbols:
|
||
# 获取股票数据，计算年线
|
||
symbol_data = data[data['symbol'] == symbol]
|
||
if len(symbol_data) < self.ma_period:
|
||
continue # 数据不够，跳过
|
||
|
||
# 计算年线
|
||
ma = symbol_data['close'].rolling(self.ma_period).mean().iloc[-1]
|
||
current_close = symbol_data['close'].iloc[-1]
|
||
|
||
if current_close > ma:
|
||
filtered.append(symbol)
|
||
|
||
return filtered
|
||
|
||
def calculate_total_score(self, processed_factors: pd.DataFrame) -> pd.Series:
|
||
"""根据因子权重计算总得分"""
|
||
total_score = None
|
||
|
||
for name, weight in self.current_weights.items():
|
||
if name not in processed_factors.columns:
|
||
continue
|
||
|
||
score = processed_factors[name] * weight
|
||
|
||
if total_score is None:
|
||
total_score = score
|
||
else:
|
||
total_score = total_score.add(score, fill_value=0)
|
||
|
||
# 降序排列，得分越高越好
|
||
if total_score is not None:
|
||
total_score = total_score.sort_values(ascending=False)
|
||
|
||
return total_score
|
||
|
||
def select_stocks(self, total_score: pd.Series, data: pd.DataFrame) -> List[str]:
|
||
"""选股:
|
||
1. 因子打分选topN*2
|
||
2. 年线过滤（如果开启）
|
||
3. 技术择时二次过滤（如果开启），只保留多头信号够的
|
||
"""
|
||
# 选topN*2得分最高
|
||
top_candidates = total_score.head(self.top_n * 3).index.tolist() # 多选一些给两轮过滤
|
||
|
||
# 第一步过滤站上年线
|
||
if self.require_above_ma:
|
||
filtered = self._filter_above_ma(top_candidates, data)
|
||
else:
|
||
filtered = top_candidates
|
||
|
||
# 第二步技术择时二次过滤
|
||
if self.tech_filter_enabled and len(filtered) > 0:
|
||
# 拿到每个股票的K线数据
|
||
symbol_data = {}
|
||
for symbol in filtered:
|
||
symbol_df = data[data['symbol'] == symbol].sort_values('date')
|
||
if len(symbol_df) > self.ma_period:
|
||
symbol_data[symbol] = symbol_df
|
||
|
||
filtered = self.tech_timing.filter_stocks_by_timing(
|
||
symbol_data,
|
||
min_bullish_score=self.min_bullish_score
|
||
)
|
||
|
||
# 如果过滤后太少，放宽再选
|
||
if len(filtered) < self.top_n // 2:
|
||
top_candidates = total_score.head(self.top_n * 4).index.tolist()
|
||
if self.require_above_ma:
|
||
filtered = self._filter_above_ma(top_candidates, data)
|
||
else:
|
||
filtered = top_candidates
|
||
|
||
if self.tech_filter_enabled and len(filtered) > 0:
|
||
symbol_data = {}
|
||
for symbol in filtered:
|
||
symbol_df = data[data['symbol'] == symbol].sort_values('date')
|
||
symbol_data[symbol] = symbol_df
|
||
filtered = self.tech_timing.filter_stocks_by_timing(
|
||
symbol_data,
|
||
min_bullish_score=self.min_bullish_score
|
||
)
|
||
|
||
# 保证不超过topN
|
||
selected = filtered[:self.top_n]
|
||
|
||
return selected
|
||
|
||
def calculate_target_weights(
|
||
self,
|
||
selected: List[str],
|
||
data: pd.DataFrame
|
||
) -> Dict[str, float]:
|
||
"""计算目标权重，考虑:
|
||
1. 整体目标仓位
|
||
2. 单票不超max_single_pct
|
||
3. 单板块不超max_sector_pct
|
||
"""
|
||
n = len(selected)
|
||
if n == 0:
|
||
return {}
|
||
|
||
# 初步等权分配，考虑单票最大限制
|
||
max_single_allowed = self.target_total_position * self.max_single_pct
|
||
equal_weight = self.target_total_position / n
|
||
|
||
# 如果等权已经超过单票最大，按最大单票
|
||
if equal_weight > max_single_allowed:
|
||
equal_weight = max_single_allowed
|
||
|
||
# 初步分配
|
||
weights = {symbol: equal_weight for symbol in selected}
|
||
|
||
# 检查板块限制
|
||
if 'sector' in data.columns:
|
||
# 获取选中股票板块
|
||
selected_data = data[data['symbol'].isin(selected)]
|
||
|
||
# 按板块汇总
|
||
sector_total = {}
|
||
for symbol in selected:
|
||
row = selected_data[selected_data['symbol'] == symbol]
|
||
sector = row['sector'].iloc[0]
|
||
if sector not in sector_total:
|
||
sector_total[sector] = 0
|
||
sector_total[sector] += weights[symbol]
|
||
|
||
# 检查超限，压缩
|
||
max_allowed = self.target_total_position * self.max_sector_pct
|
||
for sector, total_w in sector_total.items():
|
||
if total_w > max_allowed:
|
||
# 压缩比例
|
||
ratio = max_allowed / total_w
|
||
# 压缩该板块所有股票
|
||
for symbol in selected:
|
||
s_row = selected_data[selected_data['symbol'] == symbol]
|
||
s_sector = s_row['sector'].iloc[0]
|
||
if s_sector == sector:
|
||
weights[symbol] *= ratio
|
||
|
||
# 重新归一，保证总权重还是target_total_position
|
||
total = sum(weights.values())
|
||
if total > 0:
|
||
ratio = self.target_total_position / total
|
||
for symbol in weights:
|
||
weights[symbol] *= ratio
|
||
|
||
return weights
|
||
|
||
def update_dynamic_weights(self, last_data: pd.DataFrame, current_data: pd.DataFrame):
|
||
"""更新动态权重（基于IC）"""
|
||
if not self.dynamic_weight_enabled:
|
||
return
|
||
|
||
# 计算远期收益率
|
||
last_close = last_data.groupby('symbol')['close'].last()
|
||
current_close = current_data.groupby('symbol')['close'].last
|
||
forward_returns = (current_close - last_close) / last_close
|
||
|
||
# 处理因子得到当前因子得分
|
||
prepared_data = prepare_market_cap_neutral(current_data)
|
||
factor_df = batch_process_factors(self.factor_dict, prepared_data)
|
||
|
||
# 更新IC
|
||
self.current_ic = self.ic_adjuster.update_monthly_ic(factor_df, forward_returns)
|
||
|
||
# 计算新权重
|
||
new_weights = self.ic_adjuster.calculate_weights()
|
||
self.current_weights = new_weights
|
||
|
||
self.write_log(f"动态权重已更新，当前IC: {self.current_ic}")
|
||
|
||
def update_market_timing(self, market_pe: float):
|
||
"""更新估值择位"""
|
||
if not self.market_timing_enabled:
|
||
return
|
||
|
||
self.market_timer.update_monthly(market_pe)
|
||
self.target_total_position = self.market_timer.calculate_target_position()
|
||
|
||
q = self.market_timer.get_current_quantile()
|
||
if q is not None:
|
||
self.write_log(
|
||
f"估值择时更新: 分位数={q:.2f}, 目标仓位={self.target_total_position:.2f}"
|
||
)
|
||
|
||
def rebalance(self, current_date):
|
||
"""执行调仓"""
|
||
# 获取最新全市场数据
|
||
data = self.get_current_market_data()
|
||
if data is None or len(data) == 0:
|
||
self.write_log("没有数据，跳过调仓")
|
||
return
|
||
|
||
# 预处理：添加log市值用于中性化
|
||
data = prepare_market_cap_neutral(data)
|
||
|
||
# 如果开启市场状态权重分配，根据当前市场更新因子权重
|
||
if self.regime_weight_enabled:
|
||
index_data = self.get_market_index_data()
|
||
if index_data is not None:
|
||
new_weights = self.regime_allocator.get_weights(index_data)
|
||
expanded_weights = self.regime_allocator.expand_to_factor_names(new_weights)
|
||
self.current_weights = expanded_weights
|
||
current_regime = self.regime_allocator.classify_market_regime(index_data)
|
||
self.write_log(f"市场状态识别: {current_regime}, 权重已更新")
|
||
|
||
# 如果有上期数据，更新动态IC权重
|
||
if self.dynamic_weight_enabled and self.last_data is not None:
|
||
self.update_dynamic_weights(self.last_data, data)
|
||
|
||
# 如果开启择时，更新整体仓位
|
||
if self.market_timing_enabled:
|
||
market_pe = self.calculate_market_pe(data)
|
||
self.update_market_timing(market_pe)
|
||
|
||
# 批量处理所有因子（中性化+标准化+rank）
|
||
processed_factors = batch_process_factors(self.factor_dict, data)
|
||
|
||
# 计算总得分
|
||
total_score = self.calculate_total_score(processed_factors)
|
||
if total_score is None or len(total_score.dropna()) == 0:
|
||
self.write_log("计算得分失败，跳过调仓")
|
||
return
|
||
|
||
# 选股
|
||
selected = self.select_stocks(total_score, data)
|
||
|
||
if len(selected) == 0:
|
||
self.write_log("没有选中股票，跳过调仓")
|
||
return
|
||
|
||
# 计算目标权重（考虑板块和单票限制）
|
||
target_weights = self.calculate_target_weights(selected, data)
|
||
|
||
# 执行调仓
|
||
self.execute_rebalance(target_weights)
|
||
|
||
# 保存数据供下次IC计算
|
||
self.last_data = data
|
||
|
||
self.write_log(
|
||
f"调仓完成: 日期{current_date}, 选中{len(selected)}只股票, "
|
||
f"目标总仓位{self.target_total_position:.2f}"
|
||
)
|
||
|
||
def get_current_market_data(self) -> Optional[pd.DataFrame]:
|
||
"""
|
||
获取当前全市场数据
|
||
需要包含列:
|
||
- symbol: 股票代码
|
||
- date: 日期
|
||
- close: 收盘价
|
||
- pe: 市盈率
|
||
- pb: 市净率
|
||
- roe: 净资产收益率
|
||
- revenue_yoy: 营收同比增速
|
||
- profit_yoy: 利润同比增速
|
||
- market_cap: 市值
|
||
- sector: 板块
|
||
- industry_code: 行业代码（中性化用）
|
||
"""
|
||
# 这里需要对接你的数据源，接口留出
|
||
return None
|
||
|
||
def calculate_market_pe(self, data: pd.DataFrame) -> float:
|
||
"""计算全市场平均PE用于估值择时"""
|
||
pes = data['pe'].dropna()
|
||
pes = pes[pes > 0]
|
||
if len(pes) == 0:
|
||
return 15 # 默认中性值
|
||
|
||
# 中位数PE
|
||
return pes.median()
|
||
|
||
def execute_rebalance(self, target_weights: Dict[str, float]):
|
||
"""实际执行调仓"""
|
||
# 获取当前持仓
|
||
current_positions = self.get_all_positions()
|
||
|
||
# 平掉不在目标中的持仓
|
||
for pos in current_positions:
|
||
symbol = pos.vt_symbol
|
||
if symbol not in target_weights and pos.volume > 0:
|
||
self.sell(symbol, self.get_last_price(symbol), 0)
|
||
|
||
# 调整目标持仓
|
||
for symbol, target_weight in target_weights.items():
|
||
target_value = self.balance * target_weight
|
||
current_price = self.get_last_price(symbol)
|
||
if current_price <= 0:
|
||
continue
|
||
|
||
# A股整手
|
||
target_volume = int(target_value / current_price / 100) * 100
|
||
if target_volume <= 0:
|
||
continue
|
||
|
||
# 获取当前持仓
|
||
current_pos = self.get_position(symbol)
|
||
current_volume = current_pos.volume if current_pos else 0
|
||
|
||
if target_volume > current_volume:
|
||
# 加仓
|
||
volume = target_volume - current_volume
|
||
self.buy(symbol, current_price, volume)
|
||
elif target_volume < current_volume:
|
||
# 减仓
|
||
volume = current_volume - target_volume
|
||
self.sell(symbol, current_price, volume)
|
||
|
||
self.put_order()
|