资产配置如何优化才能实现夏普比率最大化并平衡风险与收益

在投资管理中，资产配置是决定投资组合长期表现的关键因素。现代投资组合理论（Modern Portfolio Theory, MPT）告诉我们，通过科学的资产配置，投资者可以在给定风险水平下获得最大收益，或在给定收益目标下承担最小风险。而夏普比率（Sharpe Ratio）作为衡量风险调整后收益的核心指标，成为优化资产配置的重要目标。本文将深入探讨如何通过量化方法优化资产配置，实现夏普比率最大化，同时有效平衡风险与收益。

一、理解夏普比率与资产配置的核心概念

1.1 夏普比率的定义与计算

夏普比率是由诺贝尔经济学奖得主威廉·夏普（William Sharpe）于1966年提出的，用于衡量投资组合每承担一单位总风险所获得的超额收益。其计算公式为：

\[ \text{Sharpe Ratio} = \frac{R_p - R_f}{\sigma_p} \]

其中：

• \(R_p\) 是投资组合的预期收益率
• \(R_f\) 是无风险利率（通常使用国债收益率）
• \(\sigma_p\) 是投资组合收益率的标准差（代表总风险）

示例：假设投资组合A的年化收益率为12%，年化波动率为15%，无风险利率为2%，则其夏普比率为 \((12\%-2\%)/15\% = 0.67\)。投资组合B的年化收益率为10%，年化波动率为8%，则其夏普比率为 \((10\%-2\%)/8\% = 1.0\)。虽然组合A的绝对收益更高，但组合B的风险调整后收益更优。

1.2 资产配置的核心原理

资产配置是指将资金分配到不同资产类别（如股票、债券、商品、现金等）的过程。其核心原理包括：

1. 分散化效应：通过投资相关性较低的资产，降低整体组合风险
2. 风险收益权衡：不同资产具有不同的风险收益特征，需要通过配置比例优化
3. 时间维度：长期投资中，资产的预期收益和风险会随时间变化

1.3 夏普比率最大化的理论基础

夏普比率最大化本质上是寻找有效前沿（Efficient Frontier）上的最优投资组合。有效前沿描述了在给定风险水平下能获得的最大收益，或在给定收益目标下的最小风险。夏普比率最大化的组合位于有效前沿上从无风险资产出发的切线与有效前沿的切点，这个切点被称为市场组合（Market Portfolio）。

二、构建优化模型：从理论到实践

2.1 基础优化模型

传统的均值-方差优化（Mean-Variance Optimization）模型可以表示为：

目标函数： $\( \max \frac{\mu^T w - R_f}{\sqrt{w^T \Sigma w}} \)$

约束条件： $\( \begin{cases} \sum_{i=1}^n w_i = 1 \\ w_i \geq 0 \quad (\text{不允许卖空}) \\ \mu^T w \geq R_{\text{target}} \quad (\text{可选：收益下限}) \end{cases} \)$

其中：

• \(w\) 是资产权重向量
• \(\mu\) 是预期收益率向量
• \(\Sigma\) 是协方差矩阵
• \(R_f\) 是无风险利率

2.2 Python实现：使用cvxpy进行优化

以下是使用Python实现夏普比率最大化的完整代码示例：

import numpy as np
import pandas as pd
import cvxpy as cp
import yfinance as yf
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

class PortfolioOptimizer:
    def __init__(self, tickers, start_date, end_date, risk_free_rate=0.02):
        """
        初始化投资组合优化器
        
        Parameters:
        -----------
        tickers : list
            资产代码列表
        start_date : str
            开始日期，格式：'YYYY-MM-DD'
        end_date : str
            结束日期，格式：'YYYY-MM-DD'
        risk_free_rate : float
            无风险利率（年化）
        """
        self.tickers = tickers
        self.start_date = start_date
        self.end_date = end_date
        self.risk_free_rate = risk_free_rate
        self.returns = None
        self.mu = None
        self.cov = None
        
    def fetch_data(self):
        """获取历史数据并计算收益率"""
        print("正在获取历史数据...")
        data = yf.download(self.tickers, start=self.start_date, end=self.end_date)['Adj Close']
        
        # 计算日收益率
        self.returns = data.pct_change().dropna()
        
        # 计算年化预期收益率和协方差矩阵
        # 假设252个交易日
        self.mu = self.returns.mean() * 252
        self.cov = self.returns.cov() * 252
        
        print(f"数据获取完成：{len(self.returns)}个观测值")
        print("\n资产预期收益率：")
        print(self.mu)
        print("\n协方差矩阵：")
        print(self.cov)
        
        return self.returns
    
    def optimize_max_sharpe(self):
        """最大化夏普比率"""
        n = len(self.tickers)
        
        # 定义权重变量
        w = cp.Variable(n)
        
        # 预期收益率
        expected_return = self.mu @ w
        
        # 投资组合方差
        portfolio_variance = cp.quad_form(w, self.cov)
        
        # 夏普比率（最大化）
        # 注意：cvxpy只能最小化，所以我们要最小化负的夏普比率
        objective = cp.Minimize(- (expected_return - self.risk_free_rate) / cp.sqrt(portfolio_variance))
        
        # 约束条件
        constraints = [
            cp.sum(w) == 1,  # 权重和为1
            w >= 0           # 不允许卖空
        ]
        
        # 求解
        problem = cp.Problem(objective, constraints)
        problem.solve(solver=cp.SCS, verbose=True)
        
        # 提取结果
        optimal_weights = w.value
        optimal_return = expected_return.value
        optimal_volatility = np.sqrt(portfolio_variance.value)
        optimal_sharpe = (optimal_return - self.risk_free_rate) / optimal_volatility
        
        return {
            'weights': optimal_weights,
            'expected_return': optimal_return,
            'volatility': optimal_volatility,
            'sharpe_ratio': optimal_sharpe
        }
    
    def optimize_target_return(self, target_return):
        """在给定目标收益率下最小化风险"""
        n = len(self.tickers)
        
        w = cp.Variable(n)
        
        expected_return = self.mu @ w
        portfolio_variance = cp.quad_form(w, self.cov)
        
        # 目标：最小化风险
        objective = cp.Minimize(cp.sqrt(portfolio_variance))
        
        constraints = [
            cp.sum(w) == 1,
            w >= 0,
            expected_return >= target_return
        ]
        
        problem = cp.Problem(objective, constraints)
        problem.solve(solver=cp.SCS, verbose=True)
        
        return {
            'weights': w.value,
            'expected_return': expected_return.value,
            'volatility': np.sqrt(portfolio_variance.value),
            'sharpe_ratio': (expected_return.value - self.risk_free_rate) / np.sqrt(portfolio_variance.value)
        }
    
    def plot_efficient_frontier(self, n_points=100):
        """绘制有效前沿"""
        # 计算有效前沿
        target_returns = np.linspace(self.mu.min(), self.mu.max(), n_points)
        volatilities = []
        sharpes = []
        
        for ret in target_returns:
            try:
                result = self.optimize_target_return(ret)
                volatilities.append(result['volatility'])
                sharpes.append(result['sharpe_ratio'])
            except:
                volatilities.append(np.nan)
                sharpes.append(np.nan)
        
        # 计算最大夏普比率组合
        max_sharpe_result = self.optimize_max_sharpe()
        
        # 绘图
        plt.figure(figsize=(12, 8))
        
        # 有效前沿
        plt.scatter(volatilities, target_returns, c=sharpes, cmap='viridis', marker='o', s=10, alpha=0.6)
        plt.colorbar(label='Sharpe Ratio')
        
        # 最大夏普比率点
        plt.scatter(max_sharpe_result['volatility'], max_sharpe_result['expected_return'], 
                   c='red', marker='*', s=200, label='Max Sharpe Ratio')
        
        # 无风险资产
        plt.scatter(0, self.risk_free_rate, c='black', marker='o', s=100, label='Risk-Free Asset')
        
        # 连接无风险资产和最大夏普比率点的切线
        plt.plot([0, max_sharpe_result['volatility']], 
                 [self.risk_free_rate, max_sharpe_result['expected_return']], 
                 'r--', alpha=0.5, label='Capital Market Line')
        
        plt.xlabel('Volatility (Standard Deviation)')
        plt.ylabel('Expected Return')
        plt.title('Efficient Frontier and Maximum Sharpe Ratio Portfolio')
        plt.legend()
        plt.grid(True, alpha=0.3)
        plt.show()
        
        return max_sharpe_result

# 使用示例
if __name__ == "__main__":
    # 定义资产池（示例：股票、债券、黄金）
    tickers = ['SPY', 'TLT', 'GLD']  # SPY:标普500, TLT:20年期国债, GLD:黄金
    
    # 设置时间范围（最近5年）
    end_date = datetime.now().strftime('%Y-%m-%d')
    start_date = (datetime.now() - timedelta(days=5*365)).strftime('%Y-%m-%d')
    
    # 创建优化器
    optimizer = PortfolioOptimizer(tickers, start_date, end_date, risk_free_rate=0.02)
    
    # 获取数据
    optimizer.fetch_data()
    
    # 优化并获取最大夏普比率组合
    print("\n" + "="*50)
    print("开始优化：最大化夏普比率")
    print("="*50)
    result = optimizer.optimize_max_sharpe()
    
    # 打印结果
    print("\n优化结果：")
    print(f"最优权重:")
    for i, ticker in enumerate(tickers):
        print(f"  {ticker}: {result['weights'][i]:.2%}")
    print(f"预期年化收益率: {result['expected_return']:.2%}")
    print(f"年化波动率: {result['volatility']:.2%}")
    print(f"夏普比率: {result['sharpe_ratio']:.4f}")
    
    # 绘制有效前沿
    optimizer.plot_efficient_frontier()

2.3 模型扩展：考虑交易成本和现实约束

在实际投资中，我们需要考虑更多现实约束：

def optimize_with_constraints(self, target_return=None, max_weight=0.4, min_weight=0.05, max_assets=4):
    """
    带约束的优化：最大权重限制、最小权重限制、资产数量限制
    """
    n = len(self.tickers)
    
    w = cp.Variable(n)
    # 二进制变量：是否持有该资产
    z = cp.Variable(n, boolean=True)
    
    expected_return = self.mu @ w
    portfolio_variance = cp.quad_form(w, self.cov)
    
    # 目标函数
    if target_return is None:
        # 最大化夏普比率
        objective = cp.Minimize(- (expected_return - self.risk_free_rate) / cp.sqrt(portfolio_variance))
    else:
        # 最小化风险
        objective = cp.Minimize(cp.sqrt(portfolio_variance))
    
    # 基础约束
    constraints = [
        cp.sum(w) == 1,
        w >= 0,
        w <= max_weight,  # 单资产最大权重
        w >= min_weight * z,  # 最小权重（如果持有）
        cp.sum(z) <= max_assets  # 最多持有资产数量
    ]
    
    # 目标收益约束
    if target_return is not None:
        constraints.append(expected_return >= target_return)
    
    # 逻辑约束：如果权重>0，则z=1
    M = 1e6
    for i in range(n):
        constraints.append(w[i] <= M * z[i])
    
    # 求解
    problem = cp.Problem(objective, constraints)
    problem.solve(solver=cp.GLPK_MI, verbose=True)
    
    # 提取结果
    optimal_weights = w.value
    optimal_weights[optimal_weights < 1e-6] = 0  # 清理数值误差
    
    if target_return is None:
        optimal_return = expected_return.value
        optimal_volatility = np.sqrt(portfolio_variance.value)
    else:
        optimal_return = target_return
        optimal_volatility = np.sqrt(portfolio_variance.value)
    
    return {
        'weights': optimal_weights,
        'expected_return': optimal_return,
        'volatility': optimal_volatility,
        'sharpe_ratio': (optimal_return - self.risk_free_rate) / optimal_volatility,
        'active_assets': [self.tickers[i] for i in range(n) if optimal_weights[i] > 0]
    }

三、高级优化技术：应对市场不确定性

3.1 鲁棒优化（Robust Optimization）

市场参数（预期收益、协方差）存在估计误差，鲁棒优化通过考虑参数的不确定性来提高稳定性：

def robust_optimization(self, uncertainty=0.1, target_return=None):
    """
    鲁棒优化：考虑预期收益的不确定性
    
    Parameters:
    -----------
    uncertainty : float
        预期收益的不确定性范围（±10%）
    """
    n = len(self.tickers)
    w = cp.Variable(n)
    
    # 基础优化
    expected_return = self.mu @ w
    portfolio_variance = cp.quad_form(w, self.cov)
    
    # 鲁棒约束：最坏情况下的收益不低于目标
    worst_case_return = expected_return - uncertainty * cp.abs(expected_return)
    
    if target_return is None:
        # 最大化最坏情况下的夏普比率
        objective = cp.Minimize(- (worst_case_return - self.risk_free_rate) / cp.sqrt(portfolio_variance))
    else:
        # 最坏情况也要满足目标收益
        objective = cp.Minimize(cp.sqrt(portfolio_variance))
        constraints = [worst_case_return >= target_return]
    
    # 基础约束
    constraints = constraints + [
        cp.sum(w) == 1,
        w >= 0
    ]
    
    problem = cp.Problem(objective, constraints)
    problem.solve(solver=cp.SCS, verbose=True)
    
    return {
        'weights': w.value,
        'expected_return': expected_return.value,
        'worst_case_return': worst_case_return.value,
        'volatility': np.sqrt(portfolio_variance.value),
        'sharpe_ratio': (expected_return.value - self.risk_free_rate) / np.sqrt(portfolio_variance.value)
    }

3.2 Black-Litterman模型：结合主观观点

Black-Litterman模型将市场均衡收益与投资者主观观点结合：

class BlackLittermanOptimizer:
    def __init__(self, tickers, start_date, end_date, risk_free_rate=0.02):
        self.tickers = tickers
        self.risk_free_rate = risk_free_rate
        self.returns = self._fetch_returns(tickers, start_date, end_date)
        self.cov = self.returns.cov() * 252
        
    def _fetch_returns(self, tickers, start_date, end_date):
        import yfinance as yf
        data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']
        return data.pct_change().dropna()
    
    def black_litterman_expected_returns(self, tau=0.05, P=None, Q=None, Omega=None):
        """
        Black-Litterman模型计算预期收益
        
        Parameters:
        -----------
        tau : float
            调整参数（反映估计不确定性）
        P : np.array
            观点矩阵
        Q : np.array
            观点收益向量
        Omega : np.array
            观点不确定性矩阵
        """
        n = len(self.tickers)
        
        # 市场均衡收益（假设市值权重）
        # 这里简化：使用等权重作为先验
        w_mkt = np.ones(n) / n
        pi = w_mkt @ self.cov @ w_mkt  # 市场风险溢价
        
        # 如果没有观点，返回均衡收益
        if P is None or Q is None:
            return pi
        
        # 计算后验收益
        # Σ^{-1}
        cov_inv = np.linalg.inv(self.cov)
        
        # 观点不确定性矩阵（如果未提供）
        if Omega is None:
            Omega = np.diag(np.diag(P @ self.cov @ P.T)) * tau
        
        # 后验均值
        # BL = [τΣ^{-1} + P'Ω^{-1}P]^{-1} [τΣ^{-1}π + P'Ω^{-1}Q]
        tau_cov_inv = tau * cov_inv
        P_Omega_inv_P = P.T @ np.linalg.inv(Omega) @ P
        
        left = tau_cov_inv + P_Omega_inv_P
        right = tau_cov_inv @ pi + P.T @ np.linalg.inv(Omega) @ Q
        
        mu_bl = np.linalg.inv(left) @ right
        
        return mu_bl
    
    def optimize_with_views(self, views, tau=0.05):
        """
        使用Black-Litterman模型进行优化
        
        views : list of tuples
            格式: [('SPY', 0.08), ...]  # 资产和预期收益
        """
        # 构建P和Q矩阵
        n = len(self.tickers)
        P = np.zeros((len(views), n))
        Q = np.zeros(len(views))
        
        for i, (asset, view_return) in enumerate(views):
            asset_idx = self.tickers.index(asset)
            P[i, asset_idx] = 1
            Q[i] = view_return
        
        # 计算BL预期收益
        mu_bl = self.black_litterman_expected_returns(tau=tau, P=P, Q=Q)
        
        # 使用BL收益进行优化
        optimizer = PortfolioOptimizer(self.tickers, '', '', self.risk_free_rate)
        optimizer.mu = pd.Series(mu_bl, index=self.tickers)
        optimizer.cov = self.cov
        
        return optimizer.optimize_max_sharpe()

四、动态资产配置与再平衡策略

4.1 动态调整：基于市场状态的配置

市场状态变化时，最优配置也会变化。我们可以实现动态调整：

class DynamicPortfolioOptimizer(PortfolioOptimizer):
    def __init__(self, tickers, start_date, end_date, risk_free_rate=0.02, window=252):
        super().__init__(tickers, start_date, end_date, risk_free_rate)
        self.window = window  # 滚动窗口（252个交易日）
        
    def rolling_optimization(self, rebalance_freq=21):
        """
        滚动窗口优化，定期再平衡
        
        Parameters:
        -----------
        rebalance_freq : int
            再平衡频率（交易日）
        """
        results = []
        n_obs = len(self.returns)
        
        # 从第window天开始
        for i in range(self.window, n_obs, rebalance_freq):
            # 使用最近window天的数据
            recent_returns = self.returns.iloc[i-self.window:i]
            
            # 重新计算mu和cov
            mu = recent_returns.mean() * 252
            cov = recent_returns.cov() * 252
            
            # 临时更新优化器参数
            self.mu = mu
            self.cov = cov
            
            # 优化
            result = self.optimize_max_sharpe()
            
            # 记录
            results.append({
                'date': self.returns.index[i],
                'weights': result['weights'],
                'expected_return': result['expected_return'],
                'volatility': result['volatility'],
                'sharpe_ratio': result['sharpe_ratio']
            })
            
            print(f"{self.returns.index[i].strftime('%Y-%m-%d')}: "
                  f"Sharpe={result['sharpe_ratio']:.4f}, "
                  f"Weights={result['weights']}")
        
        return results
    
    def backtest(self, initial_capital=100000):
        """
        回测动态策略
        """
        # 获取优化结果
        rebalance_dates = self.rolling_optimization()
        
        # 模拟投资
        capital = initial_capital
        position = None
        
        for i, rebalance in enumerate(rebalance_dates):
            date = rebalance['date']
            weights = rebalance['weights']
            
            # 计算下一期的收益（使用下一期数据）
            if i < len(rebalance_dates) - 1:
                next_date = rebalance_dates[i+1]['date']
                period_returns = self.returns.loc[date:next_date].iloc[1:]
                
                if len(period_returns) > 0:
                    # 计算组合收益
                    portfolio_returns = (period_returns * weights).sum(axis=1)
                    cumulative_return = (1 + portfolio_returns).prod() - 1
                    capital *= (1 + cumulative_return)
                    
                    print(f"Period {date.strftime('%Y-%m-%d')} to {next_date.strftime('%Y-%m-%d')}: "
                          f"Return={cumulative_return:.2%}, Capital={capital:.2f}")
        
        total_return = (capital / initial_capital) - 1
        print(f"\n总回报: {total_return:.2%}")
        return capital

4.2 再平衡成本考虑

频繁再平衡会产生交易成本，需要在优化中考虑：

def optimize_with_rebalance_cost(self, target_return=None, turnover_cost=0.001):
    """
    考虑再平衡成本的优化
    turnover_cost: 每单位换手率的成本（0.1%）
    """
    n = len(self.tickers)
    w = cp.Variable(n)
    w_prev = cp.Parameter(n, value=np.ones(n)/n)  # 上期权重
    
    expected_return = self.mu @ w
    portfolio_variance = cp.quad_form(w, self.cov)
    
    # 换手率
    turnover = cp.norm(w - w_prev, 1)
    
    # 调整后的夏普比率（扣除成本）
    net_return = expected_return - turnover * turnover_cost
    adjusted_sharpe = (net_return - self.risk_free_rate) / cp.sqrt(portfolio_variance)
    
    objective = cp.Minimize(-adjusted_sharpe)
    
    constraints = [
        cp.sum(w) == 1,
        w >= 0
    ]
    
    if target_return is not None:
        constraints.append(net_return >= target_return)
    
    problem = cp.Problem(objective, constraints)
    problem.solve(solver=cp.SCS, verbose=True)
    
    return {
        'weights': w.value,
        'expected_return': expected_return.value,
        'net_return': net_return.value,
        'volatility': np.sqrt(portfolio_variance.value),
        'turnover': turnover.value,
        'sharpe_ratio': adjusted_sharpe.value
    }

五、风险平价与全天候策略

5.1 风险平价（Risk Parity）原理

风险平价策略不追求夏普比率最大化，而是让每种资产贡献相等的风险：

def risk_parity_optimization(self):
    """
    风险平价优化：每种资产对组合风险贡献相等
    """
    n = len(self.tickers)
    w = cp.Variable(n)
    
    # 组合风险
    portfolio_variance = cp.quad_form(w, self.cov)
    portfolio_volatility = cp.sqrt(portfolio_variance)
    
    # 风险贡献（边际风险贡献）
    # RC_i = w_i * (∂σ/∂w_i) = w_i * (Σw)_i / σ
    marginal_risk_contrib = self.cov @ w / portfolio_volatility
    risk_contributions = cp.multiply(w, marginal_risk_contrib)
    
    # 目标：最小化风险贡献的差异
    # 使用L1范数最小化差异
    target_risk = portfolio_volatility / n
    objective = cp.Minimize(cp.sum(cp.abs(risk_contributions - target_risk)))
    
    constraints = [
        cp.sum(w) == 1,
        w >= 0
    ]
    
    problem = cp.Problem(objective, constraints)
    problem.solve(solver=cp.SCS, verbose=True)
    
    # 计算结果
    final_volatility = np.sqrt(portfolio_variance.value)
    final_risk_contrib = (w.value * (self.cov @ w.value) / final_volatility)
    
    return {
        'weights': w.value,
        'volatility': final_volatility,
        'risk_contributions': final_risk_contrib,
        'expected_return': self.mu @ w.value,
        'sharpe_ratio': (self.mu @ w.value - self.risk_free_rate) / final_volatility
    }

5.2 全天候策略（All-Weather Strategy）

桥水基金的全天候策略是风险平价的经典应用：

def all_weather_strategy(self):
    """
    全天候策略配置
    经典权重：股票30%，长期国债40%，中期国债15%，商品15%
    """
    # 经典全天候权重（需要根据实际资产调整）
    # 这里假设资产顺序：[股票, 长期国债, 中期国债, 商品]
    classic_weights = np.array([0.30, 0.40, 0.15, 0.15])
    
    # 如果资产数量不匹配，使用等权重
    if len(self.tickers) != 4:
        print("警告：资产数量与经典全天候策略不匹配，使用风险平价")
        return self.risk_parity_optimization()
    
    # 计算该配置的性能
    expected_return = self.mu @ classic_weights
    volatility = np.sqrt(classic_weights @ self.cov @ classic_weights)
    sharpe = (expected_return - self.risk_free_rate) / volatility
    
    return {
        'weights': classic_weights,
        'expected_return': expected_return,
        'volatility': volatility,
        'sharpe_ratio': sharpe
    }

六、实际应用与注意事项

6.1 数据质量与估计误差

关键问题：历史数据不代表未来，参数估计存在误差。

解决方案：

1. 使用更长的历史数据：至少10-20年
2. 引入贝叶斯方法：如Black-Litterman模型
3. 收缩估计：将估计值向某个目标收缩
4. 多情景分析：测试不同参数下的稳健性

6.2 交易成本与流动性

关键问题：优化结果可能产生高换手率。

解决方案：

1. 加入换手率约束：限制权重变化幅度
2. 使用交易成本模型：在目标函数中扣除成本
3. 阈值再平衡：仅当偏离超过阈值时再平衡

6.3 模型风险

关键问题：过度依赖模型，忽视市场结构性变化。

解决方案：

1. 压力测试：测试极端市场情况
2. 定期模型验证：使用样本外数据验证
3. 结合定性判断：模型结果作为参考，非绝对指令

6.4 完整实战示例

def complete_example():
    """
    完整实战示例：从数据获取到优化结果
    """
    # 1. 定义资产池（全球多元化）
    tickers = [
        'SPY',   # 美国股票
        'EFA',   # 发达国家股票
        'EEM',   # 新兴市场股票
        'TLT',   # 长期国债
        'IEF',   # 中期国债
        'GLD',   # 黄金
        'DBC'    # 商品
    ]
    
    # 2. 设置时间范围
    end_date = datetime.now().strftime('%Y-%m-%d')
    start_date = (datetime.now() - timedelta(days=10*365)).strftime('%Y-%m-%d')
    
    # 3. 创建优化器
    optimizer = PortfolioOptimizer(tickers, start_date, end_date, risk_free_rate=0.02)
    optimizer.fetch_data()
    
    # 4. 基础优化
    print("\n" + "="*60)
    print("基础夏普比率最大化")
    print("="*60)
    result_basic = optimizer.optimize_max_sharpe()
    
    # 5. 带约束优化
    print("\n" + "="*60)
    print("带约束优化（最大权重30%，最多5个资产）")
    print("="*60)
    result_constrained = optimizer.optimize_with_constraints(max_weight=0.3, max_assets=5)
    
    # 6. 鲁棒优化
    print("\n" + "="*60)
    print("鲁棒优化（考虑10%不确定性）")
    print("="*60)
    result_robust = optimizer.robust_optimization(uncertainty=0.1)
    
    # 7. 风险平价
    print("\n" + "="*60)
    print("风险平价策略")
    print("="*60)
    result_rp = optimizer.risk_parity_optimization()
    
    # 8. 结果对比
    results_df = pd.DataFrame({
        'Basic': {
            'Weights': result_basic['weights'],
            'Return': result_basic['expected_return'],
            'Volatility': result_basic['volatility'],
            'Sharpe': result_basic['sharpe_ratio']
        },
        'Constrained': {
            'Weights': result_constrained['weights'],
            'Return': result_constrained['expected_return'],
            'Volatility': result_constrained['volatility'],
            'Sharpe': result_constrained['sharpe_ratio']
        },
        'Robust': {
            'Weights': result_robust['weights'],
            'Return': result_0robust['expected_return'],
            'Volatility': result_robust['volatility'],
            'Sharpe': result_robust['sharpe_ratio']
        },
        'RiskParity': {
            'Weights': result_rp['weights'],
            'Return': result_rp['expected_return'],
            'Volatility': result_rp['volatility'],
            'Sharpe': result_rp['sharpe_ratio']
        }
    })
    
    print("\n" + "="*60)
    print("策略对比")
    print("="*60)
    print(results_df)
    
    # 9. 可视化
    optimizer.plot_efficient_frontier()
    
    return results_df

# 运行完整示例
# complete_example()

七、总结与最佳实践

7.1 核心要点回顾

1. 夏普比率最大化是优化目标，但需结合现实约束
2. 分散化是降低风险的核心，但需注意相关性在危机时会上升
3. 动态调整优于静态配置，但需控制换手率
4. 鲁棒性比最优性更重要，需考虑参数不确定性

7.2 实施建议

对于个人投资者：

• 使用4-7个资产类别进行分散
• 采用风险平价或简单60/40股债配置
• 每季度再平衡一次
• 关注低成本ETF

对于机构投资者：

• 使用Black-Litterman模型结合观点
• 实施动态风险预算
• 考虑尾部风险对冲
• 建立严格的风险监控体系

7.3 持续改进

资产配置不是一次性工作，需要：

• 定期回顾假设和参数
• 监控策略表现和风险指标
• 根据市场变化调整方法
• 保持学习和迭代

通过科学的量化方法，结合对市场的深刻理解，投资者可以构建出既能最大化夏普比率，又能有效平衡风险与收益的投资组合。记住，没有完美的模型，只有不断优化的过程。