CVaR条件风险价值：超越VaR的尾部风险管理

import numpy as np
import pandas as pd

def calculate_cvar(returns, confidence=0.95):
    """
    计算CVaR（条件风险价值）
    
    Parameters:
    -----------
    returns : array-like
        资产收益率序列（正值表示盈利，负值表示亏损）
    confidence : float
        置信水平，默认0.95
        
    Returns:
    --------
    cvar : float
        CVaR值（正数表示损失）
    var : float
        VaR值
    """
    # 转换为损失（负号表示损失）
    losses = -np.array(returns)
    
    # 计算VaR
    var = np.percentile(losses, confidence * 100)
    
    # 计算CVaR：超过VaR的损失的条件期望
    cvar = losses[losses > var].mean()
    
    return cvar, var

# 示例
np.random.seed(42)
returns = np.random.normal(0.0005, 0.02, 1000)  # 日收益率
cvar, var = calculate_cvar(returns, confidence=0.95)
print(f"VaR(95%): {var:.4f}")
print(f"CVaR(95%): {cvar:.4f}")

from scipy.stats import norm

def monte_carlo_cvar(mu, sigma, confidence=0.95, n_simulations=100000):
    """
    用蒙特卡洛模拟计算CVaR（假设正态分布）
    """
    # 生成模拟收益
    simulated_returns = np.random.normal(mu, sigma, n_simulations)
    losses = -simulated_returns
    
    # 计算VaR
    var = np.percentile(losses, confidence * 100)
    
    # 计算CVaR
    cvar = losses[losses > var].mean()
    
    # 解析解（正态分布假设下）
    # CVaR = μ + σ * φ(Φ^{-1}(α)) / (1-α)
    from scipy.stats import norm
    z_alpha = norm.ppf(confidence)
    cvar_analytical = -mu + sigma * norm.pdf(z_alpha) / (1 - confidence)
    
    return cvar, var, cvar_analytical

# 示例：日收益率均值0.05%，波动率2%
cvar_mc, var_mc, cvar_analytic = monte_carlo_cvar(0.0005, 0.02)
print(f"Monte Carlo CVaR: {cvar_mc:.4f}")
print(f"Analytical CVaR: {cvar_analytic:.4f}")

from scipy.optimize import minimize

def cvar_portfolio_optimization(returns_df, confidence=0.95, target_return=None):
    """
    CVaR投资组合优化
    
    Parameters:
    -----------
    returns_df : DataFrame
        各资产的收益率矩阵
    confidence : float
        CVaR置信水平
    target_return : float
        目标收益率（可选）
        
    Returns:
    --------
    weights : array
        最优权重
    """
    n_assets = returns_df.shape[1]
    
    def portfolio_cvar(weights):
        """计算投资组合的CVaR"""
        portfolio_returns = returns_df.dot(weights)
        cvar, _ = calculate_cvar(portfolio_returns, confidence)
        return cvar
    
    # 约束条件：权重和为1
    constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
    
    if target_return is not None:
        # 添加目标收益约束
        def return_constraint(w):
            return returns_df.dot(w).mean() - target_return
        constraints.append({'type': 'eq', 'fun': return_constraint})
    
    # 边界：不允许做空（可选）
    bounds = tuple((0, 1) for _ in range(n_assets))
    
    # 初始权重：等权
    initial_weights = np.array([1/n_assets] * n_assets)
    
    # 优化
    result = minimize(
        portfolio_cvar,
        initial_weights,
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )
    
    return result.x

# 示例
returns_df = pd.DataFrame({
    'Stock_A': np.random.normal(0.001, 0.02, 1000),
    'Stock_B': np.random.normal(0.0008, 0.015, 1000),
    'Stock_C': np.random.normal(0.0012, 0.025, 1000)
})

optimal_weights = cvar_portfolio_optimization(returns_df, confidence=0.95)
print("Optimal Weights:", optimal_weights)

def rolling_cvar(returns, window=252, confidence=0.95):
    """计算滚动CVaR"""
    cvar_series = []
    dates = []
    
    for i in range(window, len(returns)):
        roll_returns = returns[i-window:i]
        cvar, var = calculate_cvar(roll_returns, confidence)
        cvar_series.append(cvar)
        dates.append(returns.index[i])
    
    return pd.Series(cvar_series, index=dates)

# 示例：计算策略的滚动CVaR
strategy_returns = pd.Series(...)  # 你的策略收益率
rolling_cvar_series = rolling_cvar(strategy_returns, window=252)