跳转至

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. 数据管理模块:市场数据获取、清洗、存储
  2. 因子工程模块:因子计算、筛选、验证
  3. 模型演进模块:预测模型训练和优化
  4. 组合优化模块:权重分配和风险控制
  5. 回测评估模块:策略评估和归因分析

🚀 环境配置和数据准备

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

下一步行动

  1. 深入定制:根据你的需求调整策略参数
  2. 数据扩展:接入更多数据源和因子
  3. 模型优化:尝试更先进的机器学习模型
  4. 风险完善:构建更精细的风险管理体系
  5. 生产部署:将策略部署到实际交易环境

🎯 准备好挑战下一个案例了吗?

⬅️ 返回案例概览 ➡️ 进入Kaggle竞赛案例