Black-Litterman模型：桥接市场均衡与投资者观点的资产配置框架

import numpy as np
from scipy.optimize import minimize

def reverse_optimization(weights, cov_matrix, risk_aversion=2.5):
    """
    逆向优化：从市场权重推导隐含预期收益率
    
    Parameters:
    -----------
    weights : np.array, 市场组合权重
    cov_matrix : np.array, 收益率协方差矩阵
    risk_aversion : float, 风险厌恶系数
    
    Returns:
    --------
    implied_returns : np.array, 隐含预期收益率
    """
    implied_returns = risk_aversion * np.dot(cov_matrix, weights)
    return implied_returns

# 示例：假设5个资产的市值权重
market_weights = np.array([0.4, 0.3, 0.15, 0.1, 0.05])
cov_matrix = np.array([
    [0.04, 0.02, 0.01, 0.005, 0.002],
    [0.02, 0.09, 0.03, 0.01, 0.005],
    [0.01, 0.03, 0.16, 0.02, 0.01],
    [0.005, 0.01, 0.02, 0.25, 0.03],
    [0.002, 0.005, 0.01, 0.03, 0.36]
])

# 计算隐含预期收益率
pi = reverse_optimization(market_weights, cov_matrix, risk_aversion=2.5)
print("市场均衡隐含预期收益率:", pi)

# 示例观点设置
# 观点1：资产1的年化收益率将超出市场均衡3%
# 观点2：资产2的表现将比资产3好2%

Q = np.array([0.03, 0.02])  # 观点收益向量

# P矩阵：映射观点到资产
# 观点1：100% 资产1
# 观点2：资产2看多(+1)，资产3看空(-1)
P = np.array([
    [1, 0, 0, 0, 0],
    [0, 1, -1, 0, 0]
])

# 观点不确定性矩阵（对角线为观点置信度）
tau = 0.05  # 缩放因子
omega = np.diag([0.1, 0.1])  # 观点方差（越小越自信）

def black_litterman_formula(pi, P, Q, Sigma, tau, omega):
    """
    Black-Litterman公式：融合市场均衡与投资者观点
    """
    # 计算后验预期收益率
    M_inv = np.linalg.inv(tau * Sigma) + P.T @ np.linalg.inv(omega) @ P
    M = np.linalg.inv(M_inv)
    
    posterior_returns = M @ (np.linalg.inv(tau * Sigma) @ pi + P.T @ np.linalg.inv(omega) @ Q)
    
    # 计算后验协方差
    posterior_cov = M @ (P.T @ np.linalg.inv(omega) @ P + np.linalg.inv(tau * Sigma)) @ M
    
    return posterior_returns, posterior_cov

# 计算后验预期收益率和协方差
posterior_returns, posterior_cov = black_litterman_formula(
    pi, P, Q, cov_matrix, tau, omega
)

print("后验预期收益率:", posterior_returns)

def portfolio_optimization(expected_returns, cov_matrix, risk_aversion=2.5):
    """
    均值方差优化
    """
    n_assets = len(expected_returns)
    
    # 目标函数：最大化效用 = 预期收益 - 0.5 * 风险厌恶 * 方差
    def objective(weights):
        portfolio_return = np.dot(weights, expected_returns)
        portfolio_risk = np.dot(weights, np.dot(cov_matrix, weights))
        utility = portfolio_return - 0.5 * risk_aversion * portfolio_risk
        return -utility  # 最小化负效用
    
    # 约束条件
    constraints = [
        {'type': 'eq', 'fun': lambda w: np.sum(w) - 1},  # 权重和为1
    ]
    bounds = [(0, 1) for _ in range(n_assets)]  # 不允许做空
    
    # 优化
    result = minimize(
        objective,
        x0=np.ones(n_assets) / n_assets,
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )
    
    return result.x

# 优化后验预期下的组合
optimal_weights = portfolio_optimization(posterior_returns, posterior_cov, risk_aversion=2.5)
print("优化后组合权重:", optimal_weights)

import pandas as pd
import tushare as ts

# 获取历史数据（示例）
def get_historical_data():
    # 使用tushare或其他数据源
    # 返回收益率DataFrame
    pass

# 计算协方差矩阵（使用Ledoit-Wolf收缩估计）
from sklearn.covariance import LedoitWolf

def estimate_covariance(returns):
    """
    使用Ledoit-Wolf收缩估计协方差矩阵
    比样本协方差更稳健
    """
    lw = LedoitWolf()
    lw.fit(returns)
    return lw.covariance_

# 获取市场权重（以市值为代理）
market_caps = {
    '沪深300': 450000,  # 亿元
    '中证500': 120000,
    '创业板指': 80000,
    '国债': 1000000,
    '黄金ETF': 50000
}
total_market_cap = sum(market_caps.values())
market_weights = np.array([cap / total_market_cap for cap in market_caps.values()])

class BlackLittermanModel:
    """
    Black-Litterman模型完整实现
    """
    def __init__(self, returns_data, market_weights, risk_aversion=2.5, tau=0.05):
        self.returns = returns_data
        self.weights = market_weights
        self.risk_aversion = risk_aversion
        self.tau = tau
        
        # 计算协方差矩阵
        self.cov_matrix = estimate_covariance(returns_data)
        
        # 计算市场均衡预期收益率
        self.pi = reverse_optimization(market_weights, self.cov_matrix, risk_aversion)
    
    def add_view(self, P, Q, confidence=None):
        """
        添加投资者观点
        
        Parameters:
        -----------
        P : np.array, 观点映射矩阵
        Q : np.array, 观点收益向量
        confidence : np.array, 观点置信度（0-1）
        """
        self.P = P
        self.Q = Q
        
        if confidence is not None:
            # 根据置信度计算观点不确定性
            self.omega = np.diag([(1/c) - 1 for c in confidence])
        else:
            # 默认：观点不确定性正比于P * tau * Sigma * P'
            self.omega = np.diag(np.diag(self.tau * P @ self.cov_matrix @ P.T))
    
    def compute_posterior(self):
        """
        计算后验预期收益率和协方差
        """
        if not hasattr(self, 'P'):
            raise ValueError("请先添加投资观点")
        
        # Black-Litterman公式
        M_inv = np.linalg.inv(self.tau * self.cov_matrix) + \
                self.P.T @ np.linalg.inv(self.omega) @ self.P
        M = np.linalg.inv(M_inv)
        
        self.posterior_returns = M @ (
            np.linalg.inv(self.tau * self.cov_matrix) @ self.pi + 
            self.P.T @ np.linalg.inv(self.omega) @ self.Q
        )
        
        self.posterior_cov = M @ (
            self.P.T @ np.linalg.inv(self.omega) @ self.P + 
            np.linalg.inv(self.tau * self.cov_matrix)
        ) @ M
        
        return self.posterior_returns, self.posterior_cov
    
    def optimize_portfolio(self, risk_aversion=None):
        """
        优化投资组合
        """
        if not hasattr(self, 'posterior_returns'):
            self.compute_posterior()
        
        if risk_aversion is None:
            risk_aversion = self.risk_aversion
        
        optimal_weights = portfolio_optimization(
            self.posterior_returns, 
            self.posterior_cov, 
            risk_aversion
        )
        
        return optimal_weights

# 使用示例
bl_model = BlackLittermanModel(returns_data, market_weights)
bl_model.add_view(P, Q, confidence_levels)
optimal_weights = bl_model.optimize_portfolio()
print("Black-Litterman优化权重:", optimal_weights)