跳转至

RD-Agent 教程 - 第四章:实战案例教程

4.1 量化投资实战案例

完整量化策略开发

本节将通过一个完整的量化投资案例,展示如何使用 RD-Agent 从零开始开发一个多因子选股策略。

项目规划和目标设定

策略目标: - 🎯 年化收益率:目标 > 15% - 📉 最大回撤:控制在 < 8% - 📊 夏普比率:目标 > 1.5 - 🔄 换手率:控制在 < 200%/年 - 📈 信息比率:目标 > 0.8

策略框架设计:

graph TD
    A[市场数据] --> B[因子工程]
    B --> C[因子筛选]
    C --> D[模型训练]
    D --> E[信号生成]
    E --> F[组合构建]
    F --> G[风险控制]
    G --> H[执行交易]
    H --> I[绩效归因]
    I --> J[策略优化]
    J --> D

实施计划:

阶段 任务 预期时间 关键指标
第一阶段 数据准备和因子工程 2-3天 因子覆盖度 > 80%
第二阶段 因子筛选和验证 3-4天 有效因子 > 20个
第三阶段 模型开发和训练 4-5天 样本外IC > 0.05
第四阶段 组合优化和风控 2-3天 风险预算分配
第五阶段 回测验证和优化 3-4天 策略表现达标

数据准备和预处理

数据源配置:

# 数据配置示例
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": "wind/tushare",
        "fundamental": "wind/choice",
        "alternative": "eastmoney/jqdata"
    },

    "filters": {
        "min_market_cap": 5e9,       # 最小市值50亿
        "min_liquidity": 0.1,        # 最小流动性
        "exclude_st": True,          # 排除ST股票
        "exclude_new_stock": 252     # 排除上市不足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, data):
        """生成所有类别因子"""
        all_factors = {}

        for category, factor_generator in self.factor_categories.items():
            print(f"生成{category}因子...")
            factors = factor_generator.calculate(data)
            all_factors[category] = factors
            print(f"  生成{len(factors)}个因子")

        return all_factors

动量因子实现示例:

class MomentumFactors:
    """动量因子计算"""

    def calculate(self, data):
        """计算动量相关因子"""
        factors = {}

        # 1. 价格动量因子
        for period in [5, 10, 20, 60, 120]:
            factors[f'ret_{period}d'] = (
                data['close'] / data['close'].shift(period) - 1
            )

        # 2. 加权动量因子
        factors['weighted_momentum'] = self._calculate_weighted_momentum(data)

        # 3. 风险调整动量
        factors['risk_adj_momentum'] = self._calculate_risk_adjusted_momentum(data)

        # 4. 相对动量
        factors['relative_momentum'] = self._calculate_relative_momentum(data)

        return factors

    def _calculate_weighted_momentum(self, data, windows=[5, 20, 60]):
        """计算加权动量因子"""
        weights = [0.5, 0.3, 0.2]  # 近期权重更高

        momentum_components = []
        for window, weight in zip(windows, weights):
            component = (data['close'] / data['close'].shift(window) - 1) * weight
            momentum_components.append(component)

        return sum(momentum_components)

    def _calculate_risk_adjusted_momentum(self, data, return_window=20, vol_window=60):
        """计算风险调整动量"""
        returns = data['close'].pct_change(return_window)
        volatility = data['close'].pct_change().rolling(vol_window).std() * np.sqrt(252)

        return returns / volatility

    def _calculate_relative_momentum(self, data, benchmark_data):
        """计算相对动量(相对基准)"""
        stock_returns = data['close'].pct_change(20)
        benchmark_returns = benchmark_data['close'].pct_change(20)

        return stock_returns - benchmark_returns

因子筛选和验证流程

RD-Agent 因子挖掘配置:

# factor_mining_config.yaml
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

因子有效性验证:

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 = []
        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:  # 至少30只股票
                    ic = factor_cross[common_stocks].corr(return_cross[common_stocks])
                    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()

        # 排序IC
        results['rank_ic'] = self._calculate_rank_ic(factor_data, return_data)

        return results

    def _test_stability(self, factor_data, return_data):
        """测试因子稳定性"""
        # 滚动窗口测试
        window_size = 252  # 1年
        ic_rolling = []

        for i in range(window_size, len(factor_data)):
            window_factor = factor_data.iloc[i-window_size:i]
            window_return = return_data.iloc[i-window_size:i]

            ic = self._calculate_window_ic(window_factor, window_return)
            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': self._test_regime_consistency(ic_rolling)
        }

策略回测和优化

完整回测框架:

class QuantitativeStrategy:
    """量化策略回测框架"""

    def __init__(self, config):
        self.config = config
        self.factors = {}
        self.models = {}
        self.portfolio_history = []

    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 _optimize_portfolio(self, predictions, market_data, date):
        """投资组合优化"""
        from scipy.optimize import minimize

        n_assets = len(predictions)

        # 目标函数:最大化预期收益 - 风险惩罚
        def objective(weights):
            expected_return = np.dot(weights, predictions)
            risk_penalty = self._calculate_risk_penalty(weights, market_data)
            return -(expected_return - risk_penalty)

        # 约束条件
        constraints = [
            {'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0},  # 权重和为1
        ]

        # 边界条件
        bounds = [(0, 0.05) for _ in range(n_assets)]  # 单只股票权重不超过5%

        # 初始权重
        initial_weights = np.ones(n_assets) / n_assets

        # 优化求解
        result = minimize(
            objective, initial_weights,
            method='SLSQP',
            bounds=bounds,
            constraints=constraints
        )

        if result.success:
            return result.x
        else:
            print(f"优化失败: {result.message}")
            return initial_weights

    def _calculate_risk_penalty(self, weights, market_data):
        """计算风险惩罚项"""
        # 简化的风险模型
        returns = market_data['returns'].fillna(0)
        cov_matrix = returns.cov()

        portfolio_var = np.dot(weights, np.dot(cov_matrix, weights))

        return self.config.get('risk_aversion', 0.5) * portfolio_var

风险管理和组合优化

多层次风险控制:

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

    def _check_risk_limits(self, risk_type, risk_metrics):
        """检查风险限制"""
        limits = self.config.get('risk_limits', {}).get(risk_type, {})
        violations = []

        for metric, value in risk_metrics.items():
            if metric in limits:
                limit = limits[metric]
                if isinstance(limit, dict):
                    if 'max' in limit and value > limit['max']:
                        violations.append(f"{metric} 超过上限: {value} > {limit['max']}")
                    if 'min' in limit and value < limit['min']:
                        violations.append(f"{metric} 低于下限: {value} < {limit['min']}")
                else:
                    if value > limit:
                        violations.append(f"{metric} 超过限制: {value} > {limit}")

        return violations

实际运行示例:

# 使用 RD-Agent 运行量化策略开发
rdagent fin_quant \
    --config quant_strategy_config.yaml \
    --universe csi_800 \
    --start-date 2020-01-01 \
    --end-date 2024-12-31 \
    --rebalance-freq monthly

策略回测和优化

回测结果分析:

# 预期回测结果示例
backtest_results = {
    "performance_metrics": {
        "total_return": 0.267,           # 总收益率26.7%
        "annual_return": 0.156,          # 年化收益率15.6%
        "annual_volatility": 0.089,      # 年化波动率8.9%
        "sharpe_ratio": 1.75,            # 夏普比率1.75
        "max_drawdown": 0.063,           # 最大回撤6.3%
        "calmar_ratio": 2.48,            # 卡玛比率2.48
        "information_ratio": 0.84,       # 信息比率0.84
        "win_rate": 0.63,                # 胜率63%
        "profit_loss_ratio": 1.42        # 盈亏比1.42
    },

    "factor_attribution": {
        "momentum": 0.034,               # 动量因子贡献3.4%
        "quality": 0.028,                # 质量因子贡献2.8%
        "growth": 0.022,                 # 成长因子贡献2.2%
        "value": 0.019,                  # 价值因子贡献1.9%
        "mean_reversion": 0.015,         # 均值回归贡献1.5%
        "alpha": 0.038                   # 纯alpha贡献3.8%
    },

    "risk_metrics": {
        "var_95": 0.024,                 # 95% VaR为2.4%
        "expected_shortfall": 0.031,     # 期望损失3.1%
        "beta": 0.92,                    # Beta系数0.92
        "tracking_error": 0.045          # 跟踪误差4.5%
    }
}

4.2 Kaggle 竞赛完整流程

端到端自动化方案

本节通过一个完整的 Kaggle 竞赛案例,展示 RD-Agent 在机器学习竞赛中的应用。

竞赛分析和策略制定

以 "House Prices - Advanced Regression Techniques" 为例:

1. 竞赛理解:

competition_analysis = {
    "competition_name": "house-prices-advanced-regression-techniques",
    "problem_type": "regression",
    "target_variable": "SalePrice",
    "evaluation_metric": "RMSE",

    "data_characteristics": {
        "train_samples": 1460,
        "test_samples": 1459,
        "features": 79,
        "feature_types": {
            "numerical": 36,
            "categorical": 43
        },
        "missing_values": "moderate",
        "target_distribution": "right_skewed"
    },

    "key_challenges": [
        "高维稀疏特征",
        "缺失值处理",
        "特征工程重要性高",
        "需要防止过拟合",
        "异常值检测"
    ]
}

2. 解决方案架构:

graph LR
    A[原始数据] --> B[数据清洗]
    B --> C[缺失值处理]
    C --> D[特征工程]
    D --> E[特征选择]
    E --> F[模型训练]
    F --> G[模型融合]
    G --> H[后处理]
    H --> I[提交结果]

    D --> D1[数值特征]
    D --> D2[类别特征]
    D --> D3[交互特征]
    D --> D4[目标编码]

    F --> F1[XGBoost]
    F --> F2[LightGBM]
    F --> F3[CatBoost]
    F --> F4[Neural Network]

3. RD-Agent 自动化配置:

# kaggle_house_prices_config.yaml
data_science:
  competition_id: "house-prices-advanced-regression-techniques"
  problem_type: "regression"
  target_column: "SalePrice"

  preprocessing:
    missing_value_strategy: "advanced"
    outlier_detection: true
    feature_scaling: "robust"

  feature_engineering:
    automated_features: true
    interaction_terms: true
    polynomial_features: 2
    target_encoding: true

  model_selection:
    algorithms: ["xgboost", "lightgbm", "catboost", "neural_network"]
    ensemble_method: "stacking"
    cv_strategy: "stratified_kfold"
    cv_folds: 5

  optimization:
    max_iterations: 20
    population_size: 30
    hyperparameter_tuning: "bayesian"
    feature_selection: "genetic"

自动化特征工程

特征工程流水线:

class AutomatedFeatureEngineering:
    """自动化特征工程"""

    def __init__(self):
        self.feature_generators = [
            NumericalFeatureGenerator(),
            CategoricalFeatureGenerator(),
            InteractionFeatureGenerator(),
            TemporalFeatureGenerator(),
            TextFeatureGenerator()
        ]

    def generate_features(self, train_data, test_data):
        """自动生成特征"""
        print("🔧 开始自动化特征工程...")

        all_features = []
        feature_importance_scores = []

        # 基础特征处理
        processed_train, processed_test = self._preprocess_data(train_data, test_data)

        # 生成各类特征
        for generator in self.feature_generators:
            print(f"  生成 {generator.__class__.__name__} 特征...")

            new_features_train, new_features_test = generator.generate(
                processed_train, processed_test
            )

            # 特征重要性评估
            importance_scores = self._evaluate_feature_importance(
                new_features_train, train_data['SalePrice']
            )

            all_features.append({
                'train': new_features_train,
                'test': new_features_test,
                'importance': importance_scores,
                'generator': generator.__class__.__name__
            })

        # 特征选择和组合
        final_features = self._select_and_combine_features(all_features)

        return final_features

class NumericalFeatureGenerator:
    """数值特征生成器"""

    def generate(self, train_data, test_data):
        """生成数值特征"""
        numerical_cols = train_data.select_dtypes(include=[np.number]).columns

        new_features_train = {}
        new_features_test = {}

        for col in numerical_cols:
            # 1. 变换特征
            new_features_train[f'{col}_log'] = np.log1p(train_data[col])
            new_features_test[f'{col}_log'] = np.log1p(test_data[col])

            new_features_train[f'{col}_sqrt'] = np.sqrt(train_data[col])
            new_features_test[f'{col}_sqrt'] = np.sqrt(test_data[col])

            # 2. 分箱特征
            bins = pd.qcut(train_data[col], q=5, duplicates='drop')
            new_features_train[f'{col}_bin'] = bins
            new_features_test[f'{col}_bin'] = pd.cut(test_data[col], bins=bins.cat.categories)

            # 3. 统计特征
            if col.endswith('Area') or col.endswith('SF'):
                # 面积类特征的特殊处理
                new_features_train[f'{col}_per_room'] = (
                    train_data[col] / train_data.get('TotalRooms', 1)
                )
                new_features_test[f'{col}_per_room'] = (
                    test_data[col] / test_data.get('TotalRooms', 1)
                )

        return pd.DataFrame(new_features_train), pd.DataFrame(new_features_test)

class InteractionFeatureGenerator:
    """交互特征生成器"""

    def generate(self, train_data, test_data, max_interactions=50):
        """生成交互特征"""
        # 选择重要的数值特征进行交互
        important_numerical = [
            'GrLivArea', 'TotalBsmtSF', 'GarageCars', 'GarageArea',
            'YearBuilt', 'YearRemodAdd', 'MasVnrArea', 'BsmtFinSF1'
        ]

        interaction_features_train = {}
        interaction_features_test = {}

        # 两两交互
        from itertools import combinations
        for col1, col2 in combinations(important_numerical, 2):
            if col1 in train_data.columns and col2 in train_data.columns:
                # 乘积特征
                interaction_features_train[f'{col1}_x_{col2}'] = (
                    train_data[col1] * train_data[col2]
                )
                interaction_features_test[f'{col1}_x_{col2}'] = (
                    test_data[col1] * test_data[col2]
                )

                # 比值特征
                interaction_features_train[f'{col1}_div_{col2}'] = (
                    train_data[col1] / (train_data[col2] + 1)
                )
                interaction_features_test[f'{col1}_div_{col2}'] = (
                    test_data[col1] / (test_data[col2] + 1)
                )

        return (pd.DataFrame(interaction_features_train),
                pd.DataFrame(interaction_features_test))

模型集成和优化

自适应模型集成:

class AdaptiveEnsemble:
    """自适应模型集成"""

    def __init__(self):
        self.base_models = {
            'xgboost': XGBRegressor(),
            'lightgbm': LGBMRegressor(),
            'catboost': CatBoostRegressor(verbose=False),
            'random_forest': RandomForestRegressor(),
            'extra_trees': ExtraTreesRegressor(),
            'neural_network': self._create_neural_network()
        }

        self.meta_model = LinearRegression()
        self.model_weights = {}

    def train_ensemble(self, X_train, y_train, X_valid=None, y_valid=None):
        """训练集成模型"""
        print("🤖 训练自适应集成模型...")

        # 第一层:训练基础模型
        base_predictions = self._train_base_models(X_train, y_train, X_valid, y_valid)

        # 第二层:训练元模型
        if X_valid is not None and y_valid is not None:
            self._train_meta_model(base_predictions['valid'], y_valid)
        else:
            # 使用交叉验证训练元模型
            self._train_meta_model_cv(X_train, y_train)

        return base_predictions

    def _train_base_models(self, X_train, y_train, X_valid, y_valid):
        """训练基础模型"""
        base_predictions = {'train': {}, 'valid': {}}

        for name, model in self.base_models.items():
            print(f"  训练 {name}...")

            # 模型训练
            if name in ['xgboost', 'lightgbm']:
                model.fit(
                    X_train, y_train,
                    eval_set=[(X_valid, y_valid)] if X_valid is not None else None,
                    early_stopping_rounds=50,
                    verbose=False
                )
            else:
                model.fit(X_train, y_train)

            # 预测
            train_pred = model.predict(X_train)
            base_predictions['train'][name] = train_pred

            if X_valid is not None:
                valid_pred = model.predict(X_valid)
                base_predictions['valid'][name] = valid_pred

                # 计算单模型性能
                rmse = np.sqrt(mean_squared_error(y_valid, valid_pred))
                print(f"    {name} RMSE: {rmse:.4f}")

        return base_predictions

    def _create_neural_network(self):
        """创建神经网络模型"""
        from sklearn.neural_network import MLPRegressor

        return MLPRegressor(
            hidden_layer_sizes=(200, 100, 50),
            activation='relu',
            solver='adam',
            alpha=0.01,
            max_iter=500,
            early_stopping=True,
            validation_fraction=0.1
        )

    def _train_meta_model_cv(self, X_train, y_train, cv_folds=5):
        """使用交叉验证训练元模型"""
        from sklearn.model_selection import KFold

        kf = KFold(n_splits=cv_folds, shuffle=True, random_state=42)
        meta_features = np.zeros((len(X_train), len(self.base_models)))

        for fold, (train_idx, valid_idx) in enumerate(kf.split(X_train)):
            print(f"  交叉验证折 {fold + 1}/{cv_folds}")

            X_fold_train = X_train.iloc[train_idx]
            X_fold_valid = X_train.iloc[valid_idx]
            y_fold_train = y_train.iloc[train_idx]

            # 训练基础模型
            fold_predictions = []
            for name, model in self.base_models.items():
                model_copy = clone(model)
                model_copy.fit(X_fold_train, y_fold_train)
                fold_pred = model_copy.predict(X_fold_valid)
                fold_predictions.append(fold_pred)

            # 存储元特征
            meta_features[valid_idx] = np.column_stack(fold_predictions)

        # 训练元模型
        self.meta_model.fit(meta_features, y_train)

        return meta_features

最终提交准备

结果后处理和提交:

class KaggleSubmissionPipeline:
    """Kaggle 提交流水线"""

    def __init__(self, competition_id):
        self.competition_id = competition_id
        self.submission_history = []

    def prepare_submission(self, test_predictions, test_ids,
                          target_column='SalePrice'):
        """准备提交文件"""
        print("📝 准备提交文件...")

        # 后处理预测结果
        processed_predictions = self._post_process_predictions(test_predictions)

        # 创建提交数据框
        submission_df = pd.DataFrame({
            'Id': test_ids,
            target_column: processed_predictions
        })

        # 验证提交格式
        self._validate_submission_format(submission_df)

        # 生成提交文件名
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"submission_{timestamp}.csv"

        # 保存文件
        submission_df.to_csv(filename, index=False)

        print(f"✅ 提交文件已生成: {filename}")
        print(f"   预测统计:")
        print(f"   - 最小值: {processed_predictions.min():.2f}")
        print(f"   - 最大值: {processed_predictions.max():.2f}")
        print(f"   - 平均值: {processed_predictions.mean():.2f}")
        print(f"   - 中位数: {np.median(processed_predictions):.2f}")

        return filename, submission_df

    def _post_process_predictions(self, predictions):
        """后处理预测结果"""
        # 房价预测的特殊处理
        processed = predictions.copy()

        # 1. 异常值处理
        q1, q3 = np.percentile(processed, [25, 75])
        iqr = q3 - q1
        lower_bound = q1 - 1.5 * iqr
        upper_bound = q3 + 1.5 * iqr

        processed = np.clip(processed, lower_bound, upper_bound)

        # 2. 确保非负
        processed = np.maximum(processed, 1000)  # 房价至少1000

        # 3. 平滑处理
        processed = processed * 0.99 + np.median(processed) * 0.01

        return processed

完整运行流程:

# 1. 设置环境
export KAGGLE_USERNAME="your_username"
export KAGGLE_KEY="your_api_key"

# 2. 运行 RD-Agent 自动化
python tutorial_examples/chapter4/kaggle_competition_case.py

# 3. 监控进度
rdagent ui --port 19899 --data_science True

# 4. 提交结果
kaggle competitions submit \
    -c house-prices-advanced-regression-techniques \
    -f submission_final.csv \
    -m "RD-Agent automated submission"

4.3 学术研究辅助案例

论文复现项目

本节展示如何使用 RD-Agent 协助学术研究,包括论文复现、新模型开发和研究成果整理。

论文解析和理解

以复现 "Attention Is All You Need" 为例:

1. 论文信息提取:

paper_analysis = {
    "title": "Attention Is All You Need",
    "authors": ["Vaswani et al."],
    "venue": "NIPS 2017",
    "url": "https://arxiv.org/abs/1706.03762",

    "key_contributions": [
        "提出 Transformer 架构",
        "完全基于注意力机制",
        "去除循环和卷积结构",
        "在机器翻译任务上达到SOTA"
    ],

    "model_architecture": {
        "encoder_layers": 6,
        "decoder_layers": 6,
        "attention_heads": 8,
        "model_dimension": 512,
        "feedforward_dimension": 2048,
        "dropout_rate": 0.1
    },

    "key_innovations": {
        "multi_head_attention": "多头注意力机制",
        "positional_encoding": "位置编码",
        "layer_normalization": "层归一化",
        "residual_connections": "残差连接"
    }
}

2. 使用 RD-Agent 自动提取模型:

# 从论文 URL 自动提取和实现模型
rdagent general_model "https://arxiv.org/abs/1706.03762" \
    --extract-architecture \
    --implement-model \
    --run-experiments

模型架构实现

RD-Agent 生成的模型实现:

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class MultiHeadAttention(nn.Module):
    """多头注意力机制实现"""

    def __init__(self, d_model, n_heads, dropout=0.1):
        super().__init__()
        assert d_model % n_heads == 0

        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_heads

        # 线性变换层
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

        self.dropout = nn.Dropout(dropout)

    def forward(self, query, key, value, mask=None):
        batch_size, seq_len, d_model = query.size()

        # 1. 线性变换并重塑为多头
        Q = self.W_q(query).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(key).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(value).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)

        # 2. 计算注意力
        attention_output, attention_weights = self.scaled_dot_product_attention(
            Q, K, V, mask
        )

        # 3. 连接多头并应用输出投影
        attention_output = attention_output.transpose(1, 2).contiguous().view(
            batch_size, seq_len, d_model
        )

        output = self.W_o(attention_output)

        return output, attention_weights

    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        """缩放点积注意力"""
        d_k = Q.size(-1)

        # 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

        # 应用掩码
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)

        # 计算注意力权重
        attention_weights = F.softmax(scores, dim=-1)
        attention_weights = self.dropout(attention_weights)

        # 应用注意力权重
        attention_output = torch.matmul(attention_weights, V)

        return attention_output, attention_weights

class TransformerBlock(nn.Module):
    """Transformer 编码器块"""

    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()

        self.attention = MultiHeadAttention(d_model, n_heads, dropout)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

        # 前馈网络
        self.feed_forward = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model)
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        # 自注意力 + 残差连接 + 层归一化
        attention_output, attention_weights = self.attention(x, x, x, mask)
        x = self.norm1(x + self.dropout(attention_output))

        # 前馈网络 + 残差连接 + 层归一化
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))

        return x, attention_weights

class Transformer(nn.Module):
    """完整的 Transformer 模型"""

    def __init__(self, vocab_size, d_model=512, n_heads=8, n_layers=6,
                 d_ff=2048, max_seq_len=1000, dropout=0.1):
        super().__init__()

        self.d_model = d_model

        # 嵌入层
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.positional_encoding = self._create_positional_encoding(max_seq_len, d_model)

        # Transformer 层
        self.transformer_blocks = nn.ModuleList([
            TransformerBlock(d_model, n_heads, d_ff, dropout)
            for _ in range(n_layers)
        ])

        self.dropout = nn.Dropout(dropout)

    def _create_positional_encoding(self, max_seq_len, d_model):
        """创建位置编码"""
        pe = torch.zeros(max_seq_len, d_model)
        position = torch.arange(0, max_seq_len, dtype=torch.float).unsqueeze(1)

        div_term = torch.exp(torch.arange(0, d_model, 2).float() *
                           (-math.log(10000.0) / d_model))

        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)

        return pe.unsqueeze(0)

    def forward(self, x, mask=None):
        seq_len = x.size(1)

        # 词嵌入 + 位置编码
        x = self.embedding(x) * math.sqrt(self.d_model)
        x = x + self.positional_encoding[:, :seq_len].to(x.device)
        x = self.dropout(x)

        # 通过 Transformer 层
        attention_weights = []
        for transformer_block in self.transformer_blocks:
            x, attention_weight = transformer_block(x, mask)
            attention_weights.append(attention_weight)

        return x, attention_weights

实验结果验证

复现实验配置:

class TransformerExperiment:
    """Transformer 复现实验"""

    def __init__(self, config):
        self.config = config
        self.model = None
        self.optimizer = None
        self.scheduler = None

    def setup_experiment(self):
        """设置实验环境"""
        # 1. 数据加载
        self.train_loader, self.val_loader, self.test_loader = self._load_data()

        # 2. 模型初始化
        self.model = Transformer(
            vocab_size=self.config['vocab_size'],
            d_model=self.config['d_model'],
            n_heads=self.config['n_heads'],
            n_layers=self.config['n_layers'],
            d_ff=self.config['d_ff'],
            dropout=self.config['dropout']
        )

        # 3. 优化器设置
        self.optimizer = torch.optim.Adam(
            self.model.parameters(),
            lr=self.config['learning_rate'],
            betas=(0.9, 0.98),
            eps=1e-9
        )

        # 4. 学习率调度器
        self.scheduler = torch.optim.lr_scheduler.StepLR(
            self.optimizer,
            step_size=self.config['step_size'],
            gamma=self.config['gamma']
        )

    def run_training(self):
        """运行训练过程"""
        print("🚀 开始训练 Transformer 模型...")

        best_val_loss = float('inf')
        training_history = {
            'train_loss': [],
            'val_loss': [],
            'bleu_scores': []
        }

        for epoch in range(self.config['num_epochs']):
            print(f"\nEpoch {epoch + 1}/{self.config['num_epochs']}")

            # 训练
            train_loss = self._train_epoch()

            # 验证
            val_loss, bleu_score = self._validate_epoch()

            # 记录历史
            training_history['train_loss'].append(train_loss)
            training_history['val_loss'].append(val_loss)
            training_history['bleu_scores'].append(bleu_score)

            # 保存最佳模型
            if val_loss < best_val_loss:
                best_val_loss = val_loss
                self._save_checkpoint(epoch, 'best_model.pth')

            # 学习率调整
            self.scheduler.step()

            print(f"Train Loss: {train_loss:.4f}")
            print(f"Val Loss: {val_loss:.4f}")
            print(f"BLEU Score: {bleu_score:.4f}")

        return training_history

    def _train_epoch(self):
        """训练一个epoch"""
        self.model.train()
        total_loss = 0

        for batch_idx, (src, tgt) in enumerate(self.train_loader):
            self.optimizer.zero_grad()

            # 前向传播
            output, _ = self.model(src)

            # 计算损失
            loss = self._calculate_loss(output, tgt)

            # 反向传播
            loss.backward()

            # 梯度裁剪
            torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)

            # 参数更新
            self.optimizer.step()

            total_loss += loss.item()

            if batch_idx % 100 == 0:
                print(f"  Batch {batch_idx}, Loss: {loss.item():.4f}")

        return total_loss / len(self.train_loader)

    def compare_with_paper_results(self, our_results):
        """与论文结果对比"""
        paper_results = {
            'wmt_en_de': {'bleu': 28.4, 'training_time': '12_hours'},
            'wmt_en_fr': {'bleu': 41.8, 'training_time': '3.5_days'},
        }

        comparison = {}
        for dataset, paper_result in paper_results.items():
            if dataset in our_results:
                our_result = our_results[dataset]
                comparison[dataset] = {
                    'paper_bleu': paper_result['bleu'],
                    'our_bleu': our_result['bleu'],
                    'bleu_diff': our_result['bleu'] - paper_result['bleu'],
                    'reproduction_rate': our_result['bleu'] / paper_result['bleu']
                }

        return comparison

新模型开发

基于 Transformer 的改进模型:

class ImprovedTransformer(Transformer):
    """改进版 Transformer"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # 添加改进组件
        self.relative_position_encoding = RelativePositionEncoding(
            self.d_model, max_len=kwargs.get('max_seq_len', 1000)
        )

        # 增强的前馈网络
        self.enhanced_ffn = EnhancedFeedForward(
            self.d_model, kwargs.get('d_ff', 2048)
        )

    def forward(self, x, mask=None):
        seq_len = x.size(1)

        # 基础嵌入
        x = self.embedding(x) * math.sqrt(self.d_model)

        # 改进的位置编码
        x = x + self.relative_position_encoding(seq_len)
        x = self.dropout(x)

        # 通过改进的 Transformer 层
        attention_weights = []
        for i, transformer_block in enumerate(self.transformer_blocks):
            x, attention_weight = transformer_block(x, mask)

            # 在中间层添加增强前馈网络
            if i == len(self.transformer_blocks) // 2:
                x = x + self.enhanced_ffn(x)

            attention_weights.append(attention_weight)

        return x, attention_weights

class RelativePositionEncoding(nn.Module):
    """相对位置编码"""

    def __init__(self, d_model, max_len=1000):
        super().__init__()
        self.d_model = d_model
        self.max_len = max_len

        # 学习的相对位置嵌入
        self.relative_embeddings = nn.Parameter(
            torch.randn(2 * max_len - 1, d_model) * 0.02
        )

    def forward(self, seq_len):
        """计算相对位置编码"""
        positions = torch.arange(seq_len, dtype=torch.long)
        relative_positions = positions.unsqueeze(1) - positions.unsqueeze(0)
        relative_positions = relative_positions + self.max_len - 1

        # 获取相对位置嵌入
        relative_encoding = self.relative_embeddings[relative_positions]

        return relative_encoding.mean(dim=1)  # 简化实现

研究成果整理

自动生成研究报告:

class ResearchReportGenerator:
    """研究报告生成器"""

    def __init__(self, experiment_results):
        self.results = experiment_results

    def generate_full_report(self):
        """生成完整研究报告"""
        report = {
            'executive_summary': self._generate_summary(),
            'methodology': self._describe_methodology(),
            'experimental_results': self._analyze_results(),
            'comparison_analysis': self._compare_with_baselines(),
            'ablation_studies': self._conduct_ablation_studies(),
            'conclusions': self._draw_conclusions(),
            'future_work': self._suggest_future_work(),
            'reproducibility': self._create_reproducibility_guide()
        }

        return report

    def _generate_summary(self):
        """生成执行摘要"""
        return f"""
        ## 执行摘要

        本研究成功复现了 "Attention Is All You Need" 论文中的 Transformer 架构,
        并在此基础上提出了改进方案。主要贡献包括:

        1. **成功复现**:在 WMT En-De 翻译任务上达到了 {self.results.get('bleu_score', 'N/A')} BLEU分数,
           与原论文的 28.4 BLEU相比,复现率达到 {self.results.get('reproduction_rate', 'N/A')}%。

        2. **模型改进**:提出了相对位置编码和增强前馈网络,使模型性能提升了
           {self.results.get('improvement_rate', 'N/A')}%。

        3. **效率优化**:通过优化实现,训练时间相比原实现减少了
           {self.results.get('time_reduction', 'N/A')}%。
        """

    def _create_reproducibility_guide(self):
        """创建可复现性指南"""
        guide = {
            'environment_setup': {
                'python_version': '3.8+',
                'pytorch_version': '1.9+',
                'cuda_version': '11.1+',
                'required_packages': [
                    'torch', 'torchtext', 'numpy', 'matplotlib', 'tensorboard'
                ]
            },

            'data_preparation': {
                'dataset': 'WMT 2014 En-De',
                'preprocessing': 'BPE tokenization with 32K vocab',
                'train_size': '4.5M sentence pairs',
                'validation_size': '3K sentence pairs'
            },

            'training_configuration': {
                'batch_size': 25000,
                'learning_rate': '1e-3 with warmup',
                'optimizer': 'Adam (β1=0.9, β2=0.98, ε=1e-9)',
                'dropout': 0.1,
                'label_smoothing': 0.1
            },

            'hardware_requirements': {
                'minimum': '1x GPU with 8GB VRAM',
                'recommended': '4x GPU with 16GB VRAM each',
                'training_time': '12-24 hours depending on hardware'
            }
        }

        return guide


本章通过三个完整的实战案例,展示了 RD-Agent 在不同领域的强大应用能力:量化投资的端到端策略开发、Kaggle 竞赛的自动化解决方案,以及学术研究的全流程辅助。每个案例都提供了详细的实现代码和配置文件,为实际项目提供了可直接参考的模板。