RD-Agent 教程 - 第四章:量化投资实战案例¶
📊 案例概述¶
本案例将通过一个完整的量化投资项目,展示如何使用 RD-Agent 从零开始开发一个多因子选股策略。从数据准备到策略上线,涵盖量化投资的完整生命周期。
🎯 项目目标¶
策略表现目标: - 🎯 年化收益率:目标 > 15% - 📉 最大回撤:控制在 < 8% - 📊 夏普比率:目标 > 1.5 - 🔄 换手率:控制在 < 200%/年 - 📈 信息比率:目标 > 0.8
技术实现目标: - ✅ 实现端到端的量化投资流水线 - ✅ 掌握RD-Agent因子挖掘和模型演进功能 - ✅ 学会多目标优化和风险管理 - ✅ 构建可扩展的策略开发框架
📋 实施计划¶
| 阶段 | 任务 | 预期时间 | 关键指标 |
|---|---|---|---|
| 第一阶段 | 环境配置和数据准备 | 1-2小时 | 数据完整性 > 95% |
| 第二阶段 | 因子工程和筛选 | 2-3小时 | 有效因子 > 20个 |
| 第三阶段 | 模型开发和训练 | 1-2小时 | 样本外IC > 0.05 |
| 第四阶段 | 组合优化和风控 | 1-2小时 | 风险预算分配完成 |
| 第五阶段 | 回测验证和分析 | 1-2小时 | 策略表现达标 |
🏗️ 策略框架设计¶
整体架构¶
graph TD
A[市场数据] --> B[数据清洗]
B --> C[因子工程]
C --> D[因子筛选]
D --> E[模型训练]
E --> F[信号生成]
F --> G[组合构建]
G --> H[风险控制]
H --> I[执行交易]
I --> J[绩效归因]
J --> K[策略优化]
K --> E
核心模块¶
- 数据管理模块:市场数据获取、清洗、存储
- 因子工程模块:因子计算、筛选、验证
- 模型演进模块:预测模型训练和优化
- 组合优化模块:权重分配和风险控制
- 回测评估模块:策略评估和归因分析
🚀 环境配置和数据准备¶
1. 环境安装¶
# 安装核心依赖
pip install rdagent
# 安装金融数据工具
pip install yfinance tushare akshare
# 安装科学计算库
pip install pandas numpy scipy scikit-learn
# 安装可视化工具
pip install matplotlib seaborn plotly
# 安装优化工具
pip install cvxpy qpsolvers
2. 数据源配置¶
# data_config.py
data_config = {
"universe": "csi_800", # 投资域:中证800
"start_date": "2020-01-01", # 回测开始时间
"end_date": "2024-12-31", # 回测结束时间
"rebalance_freq": "monthly", # 调仓频率
"benchmark": "000906.SH", # 基准:中证800指数
"data_sources": {
"price_data": "yfinance", # 价格数据源
"fundamental": "tushare", # 基本面数据源
"alternative": "akshare" # 另类数据源
},
"filters": {
"min_market_cap": 5e9, # 最小市值50亿
"min_liquidity": 0.1, # 最小流动性
"exclude_st": True, # 排除ST股票
"exclude_new_stock": 252 # 排除上市不足1年股票
}
}
3. 数据获取和预处理¶
import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
class MarketDataManager:
"""市场数据管理器"""
def __init__(self, config):
self.config = config
self.price_data = {}
self.fundamental_data = {}
def fetch_price_data(self, symbols):
"""获取价格数据"""
print("📊 获取价格数据...")
# 使用yfinance获取数据(示例)
for symbol in symbols:
try:
ticker = yf.Ticker(symbol)
data = ticker.history(
start=self.config['start_date'],
end=self.config['end_date']
)
self.price_data[symbol] = data
print(f"✅ {symbol}: {len(data)} 条记录")
except Exception as e:
print(f"❌ {symbol}: {e}")
return self.price_data
def clean_data(self):
"""数据清洗"""
print("🧹 清洗数据...")
for symbol, data in self.price_data.items():
# 处理缺失值
data = data.fillna(method='ffill').fillna(method='bfill')
# 处理异常值
data = self._handle_outliers(data)
# 计算收益率
data['returns'] = data['Close'].pct_change()
self.price_data[symbol] = data
print("✅ 数据清洗完成")
def _handle_outliers(self, data, threshold=3):
"""处理异常值"""
returns = data['Close'].pct_change()
z_scores = np.abs((returns - returns.mean()) / returns.std())
# 将异常值替换为中位数
outlier_mask = z_scores > threshold
if outlier_mask.any():
median_return = returns.median()
data.loc[outlier_mask, 'Close'] = data['Close'].shift(1) * (1 + median_return)
return data
🔧 因子工程和筛选¶
1. 因子工程流水线¶
class FactorEngineeringPipeline:
"""因子工程流水线"""
def __init__(self):
self.factor_categories = {
"momentum": MomentumFactors(),
"mean_reversion": MeanReversionFactors(),
"quality": QualityFactors(),
"growth": GrowthFactors(),
"value": ValueFactors(),
"volatility": VolatilityFactors(),
"sentiment": SentimentFactors()
}
def generate_factors(self, price_data, fundamental_data=None):
"""生成所有类别因子"""
all_factors = {}
for category, factor_generator in self.factor_categories.items():
print(f"🔧 生成{category}因子...")
factors = factor_generator.calculate(price_data, fundamental_data)
all_factors[category] = factors
print(f" ✅ 生成{len(factors)}个因子")
return all_factors
2. 动量因子实现¶
class MomentumFactors:
"""动量因子计算"""
def calculate(self, price_data, fundamental_data=None):
"""计算动量相关因子"""
factors = {}
# 1. 价格动量因子
for period in [5, 10, 20, 60, 120]:
factors[f'ret_{period}d'] = self._calculate_price_momentum(
price_data, period
)
# 2. 加权动量因子
factors['weighted_momentum'] = self._calculate_weighted_momentum(price_data)
# 3. 风险调整动量
factors['risk_adj_momentum'] = self._calculate_risk_adjusted_momentum(price_data)
# 4. 相对动量
factors['relative_momentum'] = self._calculate_relative_momentum(price_data)
return factors
def _calculate_price_momentum(self, price_data, period):
"""计算价格动量"""
momentum_data = {}
for symbol, data in price_data.items():
if 'Close' in data.columns:
momentum = data['Close'] / data['Close'].shift(period) - 1
momentum_data[symbol] = momentum
return pd.DataFrame(momentum_data)
def _calculate_weighted_momentum(self, price_data, windows=[5, 20, 60]):
"""计算加权动量因子"""
weights = [0.5, 0.3, 0.2] # 近期权重更高
weighted_momentum = {}
for symbol, data in price_data.items():
if 'Close' in data.columns:
momentum_components = []
for window, weight in zip(windows, weights):
component = (data['Close'] / data['Close'].shift(window) - 1) * weight
momentum_components.append(component)
weighted_momentum[symbol] = sum(momentum_components)
return pd.DataFrame(weighted_momentum)
def _calculate_risk_adjusted_momentum(self, price_data, return_window=20, vol_window=60):
"""计算风险调整动量"""
risk_adj_momentum = {}
for symbol, data in price_data.items():
if 'Close' in data.columns:
returns = data['Close'].pct_change(return_window)
volatility = data['Close'].pct_change().rolling(vol_window).std() * np.sqrt(252)
risk_adj = returns / volatility.replace(0, np.nan)
risk_adj_momentum[symbol] = risk_adj
return pd.DataFrame(risk_adj_momentum)
3. 因子筛选和验证¶
class FactorValidator:
"""因子有效性验证器"""
def __init__(self, validation_config):
self.config = validation_config
def validate_factor(self, factor_data, return_data):
"""全面验证单个因子"""
validation_results = {}
# 1. 统计特性检验
validation_results['statistics'] = self._test_statistics(factor_data)
# 2. 预测能力检验
validation_results['prediction'] = self._test_prediction_power(
factor_data, return_data
)
# 3. 稳定性检验
validation_results['stability'] = self._test_stability(
factor_data, return_data
)
# 4. 独立性检验
validation_results['independence'] = self._test_independence(factor_data)
# 5. 综合评分
validation_results['composite_score'] = self._calculate_composite_score(
validation_results
)
return validation_results
def _test_prediction_power(self, factor_data, return_data):
"""测试因子预测能力"""
results = {}
# 分期计算IC
ic_series = []
dates = factor_data.index.intersection(return_data.index)
for date in dates:
factor_cross = factor_data.loc[date].dropna()
return_cross = return_data.loc[date].dropna()
# 计算截面相关性
common_stocks = factor_cross.index.intersection(return_cross.index)
if len(common_stocks) >= 30: # 至少30只股票
ic = factor_cross[common_stocks].corr(return_cross[common_stocks])
if not np.isnan(ic):
ic_series.append(ic)
ic_series = pd.Series(ic_series)
results['ic_mean'] = ic_series.mean()
results['ic_std'] = ic_series.std()
results['ic_ir'] = ic_series.mean() / ic_series.std() if ic_series.std() > 0 else 0
results['ic_positive_ratio'] = (ic_series > 0).mean()
return results
def _test_stability(self, factor_data, return_data):
"""测试因子稳定性"""
# 滚动窗口测试
window_size = 252 # 1年
ic_rolling = []
dates = factor_data.index.intersection(return_data.index)
for i in range(window_size, len(dates)):
window_dates = dates[i-window_size:i]
window_factor = factor_data.loc[window_dates]
window_return = return_data.loc[window_dates]
ic = self._calculate_window_ic(window_factor, window_return)
if not np.isnan(ic):
ic_rolling.append(ic)
ic_rolling = pd.Series(ic_rolling)
return {
'ic_stability': ic_rolling.std(),
'ic_trend': self._detect_trend(ic_rolling),
'regime_consistency': len(ic_rolling[ic_rolling > 0]) / len(ic_rolling)
}
def _calculate_window_ic(self, factor_data, return_data):
"""计算窗口期IC"""
ic_list = []
for date in factor_data.index:
if date in return_data.index:
factor_cross = factor_data.loc[date].dropna()
return_cross = return_data.loc[date].dropna()
common_stocks = factor_cross.index.intersection(return_cross.index)
if len(common_stocks) >= 30:
ic = factor_cross[common_stocks].corr(return_cross[common_stocks])
if not np.isnan(ic):
ic_list.append(ic)
return np.mean(ic_list) if ic_list else np.nan
def _detect_trend(self, series):
"""检测趋势"""
if len(series) < 2:
return 0
x = np.arange(len(series))
slope = np.polyfit(x, series, 1)[0]
return slope
🤖 RD-Agent 因子挖掘配置¶
1. 配置文件¶
# factor_mining_config.yaml
factor_mining:
scenario: "factor_mining"
max_iterations: 15
population_size: 40
factor_universe:
- momentum_factors
- quality_factors
- growth_factors
- value_factors
- sentiment_factors
evaluation_metrics:
primary: "information_coefficient"
secondary: ["rank_ic", "ic_ir", "turnover"]
constraints:
max_turnover: 2.0 # 最大年换手率200%
min_ic: 0.03 # 最小IC阈值
min_coverage: 0.7 # 最小覆盖率70%
optimization:
objective: "multi_objective"
weights:
ic: 0.4
ic_ir: 0.3
turnover: -0.2 # 负权重,希望越小越好
coverage: 0.1
llm:
chat_model: "gpt-4o-mini"
api_key: "your_openai_api_key"
temperature: 0.1
max_tokens: 4000
data:
train_start: "2020-01-01"
train_end: "2023-12-31"
test_start: "2024-01-01"
test_end: "2024-12-31"
2. 运行因子挖掘¶
# 使用 RD-Agent 运行因子挖掘
rdagent fin_factor --config factor_mining_config.yaml
3. 因子挖掘结果分析¶
class FactorMiningResultAnalyzer:
"""因子挖掘结果分析器"""
def __init__(self, results_path):
self.results_path = results_path
self.results = self._load_results()
def _load_results(self):
"""加载挖掘结果"""
import json
with open(self.results_path, 'r') as f:
results = json.load(f)
return results
def analyze_factor_performance(self):
"""分析因子表现"""
factors = self.results.get('discovered_factors', [])
performance_summary = {
'total_factors': len(factors),
'high_ic_factors': len([f for f in factors if f.get('ic', 0) > 0.05]),
'stable_factors': len([f for f in factors if f.get('ic_ir', 0) > 1.0]),
'low_turnover_factors': len([f for f in factors if f.get('turnover', 999) < 1.0])
}
# 按IC排序
factors_by_ic = sorted(factors, key=lambda x: x.get('ic', 0), reverse=True)
performance_summary['top_factors'] = factors_by_ic[:10]
return performance_summary
def generate_factor_report(self):
"""生成因子报告"""
performance = self.analyze_factor_performance()
report = f"""
# 因子挖掘结果报告
## 概要统计
- 总发现因子数量: {performance['total_factors']}
- 高IC因子数量: {performance['high_ic_factors']} (IC > 0.05)
- 稳定因子数量: {performance['stable_factors']} (IC_IR > 1.0)
- 低换手因子数量: {performance['low_turnover_factors']} (换手率 < 100%)
## Top 10 因子
"""
for i, factor in enumerate(performance['top_factors'], 1):
report += f"{i}. {factor.get('name', 'Unknown')}: IC={factor.get('ic', 0):.4f}, IC_IR={factor.get('ic_ir', 0):.2f}\n"
return report
📈 模型开发和训练¶
1. 模型演进配置¶
# model_evolution_config.yaml
model_evolution:
scenario: "model_evolution"
max_iterations: 20
population_size: 30
models:
linear: ["LinearRegression", "Ridge", "Lasso", "ElasticNet"]
tree: ["RandomForest", "XGBoost", "LightGBM", "CatBoost"]
neural: ["MLP", "TabNet"]
ensemble: ["Stacking", "Voting", "Blending"]
hyperparameter_tuning:
method: "bayesian"
n_trials: 100
cv_folds: 3
feature_selection:
method: "recursive"
max_features: 50
importance_threshold: 0.01
evaluation:
metrics: ["ic", "rank_ic", "sharpe_ratio"]
cross_validation: true
time_series_split: true
llm:
chat_model: "gpt-4o-mini"
api_key: "your_openai_api_key"
temperature: 0.1
2. 运行模型演进¶
# 使用 RD-Agent 运行模型演进
rdagent fin_model --config model_evolution_config.yaml
3. 自定义预测模型¶
import xgboost as xgb
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Ridge
class PredictionModelEnsemble:
"""预测模型集成"""
def __init__(self, config):
self.config = config
self.models = self._initialize_models()
self.model_weights = {}
def _initialize_models(self):
"""初始化模型"""
models = {
'xgboost': xgb.XGBRegressor(
n_estimators=100,
learning_rate=0.1,
max_depth=6,
random_state=42
),
'random_forest': RandomForestRegressor(
n_estimators=100,
max_depth=10,
random_state=42
),
'ridge': Ridge(alpha=1.0)
}
return models
def train(self, X_train, y_train, X_val, y_val):
"""训练所有模型"""
print("🚂 训练预测模型...")
model_scores = {}
for name, model in self.models.items():
print(f" 训练 {name}...")
# 训练模型
model.fit(X_train, y_train)
# 验证性能
y_pred = model.predict(X_val)
ic = np.corrcoef(y_val, y_pred)[0, 1]
model_scores[name] = ic
print(f" 验证IC: {ic:.4f}")
# 计算模型权重
self._calculate_model_weights(model_scores)
return model_scores
def _calculate_model_weights(self, scores):
"""计算模型权重"""
# 基于IC计算权重
total_score = sum(max(0, score) for score in scores.values())
if total_score > 0:
self.model_weights = {
name: max(0, score) / total_score
for name, score in scores.items()
}
else:
# 等权重
self.model_weights = {
name: 1.0 / len(scores)
for name in scores.keys()
}
def predict(self, X):
"""集成预测"""
predictions = {}
for name, model in self.models.items():
predictions[name] = model.predict(X)
# 加权平均
ensemble_pred = np.zeros(len(X))
for name, pred in predictions.items():
weight = self.model_weights.get(name, 0)
ensemble_pred += weight * pred
return ensemble_pred
def get_feature_importance(self):
"""获取特征重要性"""
importance_dict = {}
for name, model in self.models.items():
weight = self.model_weights.get(name, 0)
if hasattr(model, 'feature_importances_'):
importance = model.feature_importances_ * weight
importance_dict[name] = importance
elif hasattr(model, 'coef_'):
importance = np.abs(model.coef_) * weight
importance_dict[name] = importance
# 平均重要性
if importance_dict:
avg_importance = np.mean(list(importance_dict.values()), axis=0)
return avg_importance
return None
🎯 组合优化和风险控制¶
1. 投资组合优化器¶
import cvxpy as cp
from scipy.optimize import minimize
class PortfolioOptimizer:
"""投资组合优化器"""
def __init__(self, config):
self.config = config
def optimize_portfolio(self, expected_returns, risk_model, market_data):
"""优化投资组合"""
n_assets = len(expected_returns)
# 决策变量:权重
weights = cp.Variable(n_assets)
# 目标函数:最大化预期收益 - 风险惩罚
expected_return = expected_returns.T @ weights
risk_penalty = cp.quad_form(weights, risk_model)
risk_aversion = self.config.get('risk_aversion', 0.5)
objective = cp.Maximize(expected_return - risk_aversion * risk_penalty)
# 约束条件
constraints = [
# 权重和为1
cp.sum(weights) == 1,
# 个股权重限制
weights >= -0.02, # 最大做空2%
weights <= 0.05, # 最大做多5%
# 行业权重限制
self._add_sector_constraints(weights, market_data),
# 换手率限制
self._add_turnover_constraints(weights, market_data)
]
# 求解优化问题
problem = cp.Problem(objective, constraints)
problem.solve()
if problem.status == cp.OPTIMAL:
return weights.value
else:
print(f"优化失败: {problem.status}")
return np.ones(n_assets) / n_assets
def _add_sector_constraints(self, weights, market_data):
"""添加行业约束"""
constraints = []
sector_limits = self.config.get('sector_limits', {})
for sector, limit in sector_limits.items():
sector_mask = market_data['sector'] == sector
if sector_mask.any():
sector_weight = cp.sum(weights[sector_mask])
constraints.append(sector_weight <= limit)
return constraints
def _add_turnover_constraints(self, weights, market_data):
"""添加换手率约束"""
current_weights = market_data.get('current_weights', np.zeros(len(weights)))
max_turnover = self.config.get('max_turnover', 1.0)
turnover = cp.norm(weights - current_weights, 1)
return [turnover <= max_turnover]
2. 风险管理系统¶
class RiskManagementSystem:
"""风险管理系统"""
def __init__(self, risk_config):
self.config = risk_config
self.risk_monitors = {
'market_risk': MarketRiskMonitor(),
'factor_risk': FactorRiskMonitor(),
'concentration_risk': ConcentrationRiskMonitor(),
'liquidity_risk': LiquidityRiskMonitor()
}
def assess_portfolio_risk(self, portfolio, market_data):
"""评估组合风险"""
risk_assessment = {}
for risk_type, monitor in self.risk_monitors.items():
risk_metrics = monitor.calculate_risk(portfolio, market_data)
risk_assessment[risk_type] = risk_metrics
# 检查风险限制
violations = self._check_risk_limits(risk_type, risk_metrics)
if violations:
risk_assessment[f'{risk_type}_violations'] = violations
# 综合风险评分
risk_assessment['composite_risk_score'] = self._calculate_composite_risk(
risk_assessment
)
return risk_assessment
def generate_risk_report(self, portfolio, market_data, date):
"""生成风险报告"""
risk_assessment = self.assess_portfolio_risk(portfolio, market_data)
report = {
'date': date,
'portfolio_summary': self._get_portfolio_summary(portfolio),
'risk_metrics': risk_assessment,
'risk_attribution': self._calculate_risk_attribution(portfolio),
'recommendations': self._generate_risk_recommendations(risk_assessment)
}
return report
class MarketRiskMonitor:
"""市场风险监控"""
def calculate_risk(self, portfolio, market_data):
"""计算市场风险"""
# Beta风险
market_beta = self._calculate_portfolio_beta(portfolio, market_data)
# VaR计算
portfolio_var = self._calculate_var(portfolio, market_data)
# 波动率
portfolio_volatility = self._calculate_volatility(portfolio, market_data)
return {
'market_beta': market_beta,
'value_at_risk_95': portfolio_var,
'portfolio_volatility': portfolio_volatility,
'tracking_error': self._calculate_tracking_error(portfolio, market_data)
}
📊 回测和性能评估¶
1. 回测框架¶
class QuantitativeStrategy:
"""量化策略回测框架"""
def __init__(self, config):
self.config = config
self.factors = {}
self.models = {}
self.portfolio_history = []
self.performance_metrics = {}
def run_backtest(self, start_date, end_date):
"""运行完整回测"""
print(f"🔄 开始回测: {start_date} 至 {end_date}")
# 初始化
self._initialize_backtest()
# 按调仓周期循环
rebalance_dates = self._get_rebalance_dates(start_date, end_date)
for i, rebalance_date in enumerate(rebalance_dates):
print(f"📅 调仓日期: {rebalance_date} ({i+1}/{len(rebalance_dates)})")
# 1. 更新数据
current_data = self._get_current_data(rebalance_date)
# 2. 计算因子暴露
factor_exposure = self._calculate_factor_exposure(
current_data, rebalance_date
)
# 3. 模型预测
predictions = self._generate_predictions(
factor_exposure, rebalance_date
)
# 4. 组合优化
portfolio_weights = self._optimize_portfolio(
predictions, current_data, rebalance_date
)
# 5. 执行交易
self._execute_rebalance(portfolio_weights, rebalance_date)
# 6. 风险监控
self._monitor_risk(rebalance_date)
# 计算回测结果
backtest_results = self._calculate_backtest_results()
return backtest_results
def _calculate_backtest_results(self):
"""计算回测结果"""
portfolio_returns = self._get_portfolio_returns()
benchmark_returns = self._get_benchmark_returns()
# 计算性能指标
results = {
'total_return': self._calculate_total_return(portfolio_returns),
'annual_return': self._calculate_annual_return(portfolio_returns),
'volatility': self._calculate_volatility(portfolio_returns),
'sharpe_ratio': self._calculate_sharpe_ratio(portfolio_returns),
'max_drawdown': self._calculate_max_drawdown(portfolio_returns),
'information_ratio': self._calculate_information_ratio(
portfolio_returns, benchmark_returns
),
'calmar_ratio': self._calculate_calmar_ratio(portfolio_returns),
'win_rate': self._calculate_win_rate(portfolio_returns),
'average_turnover': self._calculate_average_turnover()
}
return results
def _calculate_sharpe_ratio(self, returns, risk_free_rate=0.03):
"""计算夏普比率"""
excess_returns = returns - risk_free_rate / 252
return np.sqrt(252) * excess_returns.mean() / returns.std()
def _calculate_max_drawdown(self, returns):
"""计算最大回撤"""
cumulative = (1 + returns).cumprod()
rolling_max = cumulative.expanding().max()
drawdown = (cumulative - rolling_max) / rolling_max
return drawdown.min()
def _calculate_information_ratio(self, portfolio_returns, benchmark_returns):
"""计算信息比率"""
active_returns = portfolio_returns - benchmark_returns
return np.sqrt(252) * active_returns.mean() / active_returns.std()
2. 性能归因分析¶
class PerformanceAttribution:
"""性能归因分析"""
def __init__(self, factor_loadings, factor_returns, specific_returns):
self.factor_loadings = factor_loadings
self.factor_returns = factor_returns
self.specific_returns = specific_returns
def calculate_attribution(self, portfolio_weights, benchmark_weights):
"""计算性能归因"""
# 因子暴露差异
factor_exposure_diff = (
portfolio_weights.T @ self.factor_loadings -
benchmark_weights.T @ self.factor_loadings
)
# 因子收益贡献
factor_contribution = factor_exposure_diff * self.factor_returns
# 个股选择贡献
stock_selection = (portfolio_weights - benchmark_weights) * self.specific_returns
attribution_results = {
'total_excess_return': factor_contribution.sum() + stock_selection.sum(),
'factor_contribution': factor_contribution,
'stock_selection': stock_selection.sum(),
'factor_breakdown': {
'style_factors': self._breakdown_style_factors(factor_contribution),
'industry_factors': self._breakdown_industry_factors(factor_contribution)
}
}
return attribution_results
def generate_attribution_report(self, attribution_results):
"""生成归因报告"""
report = f"""
# 性能归因分析报告
## 总体表现
- 总超额收益: {attribution_results['total_excess_return']:.4f}
- 因子贡献: {attribution_results['factor_contribution'].sum():.4f}
- 个股选择贡献: {attribution_results['stock_selection']:.4f}
## 风格因子贡献
"""
for factor, contribution in attribution_results['factor_breakdown']['style_factors'].items():
report += f"- {factor}: {contribution:.4f}\n"
return report
3. 可视化分析¶
import matplotlib.pyplot as plt
import seaborn as sns
class PerformanceVisualizer:
"""性能可视化"""
def __init__(self, results):
self.results = results
plt.style.use('seaborn-v0_8')
def plot_performance_summary(self, save_path=None):
"""绘制性能总结图"""
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 12))
# 1. 累计收益曲线
self._plot_cumulative_returns(ax1)
# 2. 回撤曲线
self._plot_drawdown(ax2)
# 3. 滚动夏普比率
self._plot_rolling_sharpe(ax3)
# 4. 月度收益分布
self._plot_monthly_returns(ax4)
plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=300, bbox_inches='tight')
plt.show()
def _plot_cumulative_returns(self, ax):
"""绘制累计收益曲线"""
portfolio_cum = (1 + self.results['portfolio_returns']).cumprod()
benchmark_cum = (1 + self.results['benchmark_returns']).cumprod()
ax.plot(portfolio_cum.index, portfolio_cum.values,
label='策略', linewidth=2, color='blue')
ax.plot(benchmark_cum.index, benchmark_cum.values,
label='基准', linewidth=2, color='red')
ax.set_title('累计收益对比')
ax.set_ylabel('累计收益')
ax.legend()
ax.grid(True, alpha=0.3)
def _plot_drawdown(self, ax):
"""绘制回撤曲线"""
returns = self.results['portfolio_returns']
cumulative = (1 + returns).cumprod()
rolling_max = cumulative.expanding().max()
drawdown = (cumulative - rolling_max) / rolling_max
ax.fill_between(drawdown.index, drawdown.values, 0,
alpha=0.3, color='red')
ax.plot(drawdown.index, drawdown.values, color='red')
ax.set_title('策略回撤')
ax.set_ylabel('回撤比例')
ax.grid(True, alpha=0.3)
def plot_factor_analysis(self, factor_returns, save_path=None):
"""绘制因子分析图"""
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
# 因子收益分布
factor_returns.boxplot(ax=ax1)
ax1.set_title('因子收益分布')
ax1.set_ylabel('收益率')
ax1.tick_params(axis='x', rotation=45)
# 因子相关性热图
corr_matrix = factor_returns.corr()
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, ax=ax2)
ax2.set_title('因子相关性矩阵')
plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=300, bbox_inches='tight')
plt.show()
🚀 实际运行示例¶
1. 完整执行流程¶
# main.py - 主执行脚本
def main():
print("🎯 RD-Agent 量化投资策略开发")
print("=" * 50)
# 1. 配置参数
config = {
'data_config': data_config,
'factor_config': 'factor_mining_config.yaml',
'model_config': 'model_evolution_config.yaml',
'portfolio_config': {
'risk_aversion': 0.5,
'max_turnover': 1.0,
'sector_limits': {
'Technology': 0.3,
'Finance': 0.2,
'Healthcare': 0.15
}
}
}
# 2. 数据准备
print("\n📊 第一步:数据准备")
data_manager = MarketDataManager(config['data_config'])
# 示例股票池(A股前50大市值股票)
symbols = [
'000001.SZ', '000002.SZ', '000858.SZ', '000725.SZ', '002415.SZ',
'600000.SH', '600036.SH', '600519.SH', '600887.SH', '601318.SH'
]
price_data = data_manager.fetch_price_data(symbols)
data_manager.clean_data()
# 3. 因子工程
print("\n🔧 第二步:因子工程")
factor_pipeline = FactorEngineeringPipeline()
all_factors = factor_pipeline.generate_factors(price_data)
# 4. 因子验证
print("\n✅ 第三步:因子验证")
validator = FactorValidator({'min_ic': 0.03, 'min_coverage': 0.7})
valid_factors = {}
for category, factors in all_factors.items():
valid_factors[category] = {}
for factor_name, factor_data in factors.items():
# 使用前一期因子预测下期收益
returns_data = pd.DataFrame({
symbol: data['returns'].shift(-1) for symbol, data in price_data.items()
})
validation_result = validator.validate_factor(factor_data, returns_data)
if validation_result['composite_score'] > 0.5:
valid_factors[category][factor_name] = factor_data
print(f" ✅ {factor_name}: IC={validation_result['prediction']['ic_mean']:.4f}")
# 5. 运行 RD-Agent 因子挖掘
print("\n🤖 第四步:RD-Agent 因子挖掘")
os.system("rdagent fin_factor --config factor_mining_config.yaml")
# 6. 运行 RD-Agent 模型演进
print("\n🧠 第五步:RD-Agent 模型演进")
os.system("rdagent fin_model --config model_evolution_config.yaml")
# 7. 策略回测
print("\n📈 第六步:策略回测")
strategy = QuantitativeStrategy(config)
backtest_results = strategy.run_backtest('2022-01-01', '2024-12-31')
# 8. 结果分析
print("\n📊 第七步:结果分析")
print("策略表现:")
for metric, value in backtest_results.items():
if isinstance(value, float):
print(f" {metric}: {value:.4f}")
else:
print(f" {metric}: {value}")
# 9. 可视化
print("\n📈 第八步:可视化分析")
visualizer = PerformanceVisualizer(backtest_results)
visualizer.plot_performance_summary('strategy_performance.png')
print("\n🎉 量化投资策略开发完成!")
if __name__ == "__main__":
main()
2. 命令行运行¶
# 创建项目目录
mkdir quantitative_investment_project
cd quantitative_investment_project
# 运行案例代码
python /path/to/tutorial_examples/chapter4/quantitative_investment_case.py
# 或者直接运行主脚本
python main.py
📋 案例总结¶
学习收获¶
通过本案例,你应该掌握了:
✅ 完整的量化投资开发流程:从数据获取到策略上线 ✅ RD-Agent核心功能:因子挖掘、模型演进、联合优化 ✅ 风险管理体系:多层次风险控制和监控 ✅ 性能评估方法:回测分析和归因分解 ✅ 项目工程化实践:代码结构、配置管理、可视化
扩展方向¶
- 🔮 实时交易系统:将策略部署到实盘交易
- 📡 另类数据集成:新闻、社交媒体、卫星数据
- 🤖 强化学习:基于RL的组合优化
- 🌐 多市场策略:跨市场套利和配置
- 📱 移动端监控:实时策略监控APP
下一步行动¶
- 深入定制:根据你的需求调整策略参数
- 数据扩展:接入更多数据源和因子
- 模型优化:尝试更先进的机器学习模型
- 风险完善:构建更精细的风险管理体系
- 生产部署:将策略部署到实际交易环境
🎯 准备好挑战下一个案例了吗?
⬅️ 返回案例概览 ➡️ 进入Kaggle竞赛案例