AI投资：从资本开支狂飙到价值兑现的专业框架

"""
PEGR估值模型 — 隐含终值动态回收期（ITV-DPP）计算
用于AI/科技企业估值，替代传统DCF中不可验证的永续增长率假设

核心逻辑：从市场价格出发，倒推市场隐含的终值回收期，
并与市场平均动态回收期（MA-DPP=12年）进行比较，
判断当前估值是否在有效预测期内可被合理解释。
"""

import numpy as np
from dataclasses import dataclass
from typing import Optional


@dataclass
class PEGRInputs:
    """PEGR估值输入参数"""
    market_cap: float          # 当前市值（亿美元）
    net_income: float          # 当前净利润（亿美元）
    growth_rate_g1: float      # 可预测期净利润复合增长率（如0.30 = 30%）
    predict_years: int = 5     # 可预测期年数
    discount_rate: float = 0.10  # 可预测期必要收益率（折现率）


def peg_ratio(market_cap: float, net_income: float,
              growth_rate: float) -> float:
    """
    计算传统PEG比率
    PEG = (P/E) / (g * 100)
    通常PEG < 1 视为低估，> 2 视为高估
    """
    if growth_rate <= 0 or net_income <= 0:
        return float('inf')
    pe = market_cap / net_income
    return pe / (growth_rate * 100)


def implied_terminal_dpp(inputs: PEGRInputs,
                          max_dpp: int = 25) -> dict:
    """
    计算隐含终值动态回收期（ITV-DPP）

    方法：在可预测期内按g1增长，预测期结束后
    从市值中减去可预测期贡献的现值，
    剩余部分即为市场对终值的隐含定价。
    然后反推：以可预测期末净利润为基数，
    在何种增长率g2下，终值现值能在DPP年内收回。

    Returns:
        dict: 包含g1贡献占比、隐含终值定价、隐含g2、ITV-DPP等
    """
    mc = inputs.market_cap
    ni = inputs.net_income
    g1 = inputs.growth_rate_g1
    n = inputs.predict_years
    r = inputs.discount_rate

    # 第1步：计算可预测期各年净利润现值
    pv_predict = 0.0
    for t in range(1, n + 1):
        ni_t = ni * (1 + g1) ** t
        pv_predict += ni_t / (1 + r) ** t

    # 第2步：可预测期贡献占比
    pv_predict_ratio = pv_predict / mc if mc > 0 else float('inf')

    # 第3步：隐含终值定价 = 市值 - 可预测期贡献
    implied_terminal_value = mc - pv_predict

    if implied_terminal_value <= 0:
        return {
            "pv_predict": round(pv_predict, 2),
            "pv_predict_ratio": round(pv_predict_ratio, 4),
            "implied_terminal_value": 0,
            "implied_g2": None,
            "implied_dpp": None,
            "verdict": "可预测期内已覆盖市值，无明显梦想溢价"
        }

    # 第4步：反推隐含终值增长率g2
    # 假设终值是一个以可预测期末净利润为基数、
    # 以g2永续增长的现金流序列的现值
    ni_end = ni * (1 + g1) ** n  # 预测期末净利润

    # 终值现值 = ni_end * (1+g2) / (r - g2)   (Gordon增长模型)
    # 令 终值现值 = implied_terminal_value，解g2
    # implied_tv * (r - g2) = ni_end * (1 + g2)
    # implied_tv * r - implied_tv * g2 = ni_end + ni_end * g2
    # g2 * (implied_tv + ni_end) = implied_tv * r - ni_end
    numerator = implied_terminal_value * r - ni_end
    denominator = implied_terminal_value + ni_end

    if denominator == 0 or numerator <= 0:
        implied_g2 = 0.0
    else:
        implied_g2 = numerator / denominator

    # 第5步：计算隐含动态回收期
    # 以可预测期末为起点，计算累计现值回收隐含终值所需年数
    implied_dpp = None
    if implied_g2 > 0 and implied_g2 < r:
        cumulative = 0.0
        for t in range(1, max_dpp + 1):
            cf_t = ni_end * (1 + implied_g2) ** t
            pv_t = cf_t / (1 + r) ** (n + t)
            cumulative += pv_t
            if cumulative >= implied_terminal_value:
                implied_dpp = t
                break
    elif implied_g2 >= r:
        implied_dpp = max_dpp  # g2 >= r时永续模型失效，回收期无限

    # 第6步：判断
    MA_DPP = 12  # 市场平均动态回收期（美股50年历史均值）
    if implied_dpp is None:
        verdict = "⚠️ 隐含终值无法在合理期限内回收，估值严重透支远期预期"
    elif implied_dpp <= MA_DPP:
        verdict = f"✅ ITV-DPP={implied_dpp}年 ≤ MA-DPP={MA_DPP}年，估值在有效预测期内可被解释"
    else:
        verdict = f"⚠️ ITV-DPP={implied_dpp}年 > MA-DPP={MA_DPP}年，估值透支远期预期，需审视增长假设"

    return {
        "pv_predict": round(pv_predict, 2),
        "pv_predict_ratio": round(pv_predict_ratio, 4),
        "implied_terminal_value": round(implied_terminal_value, 2),
        "implied_g2": round(implied_g2, 4) if implied_g2 else None,
        "implied_dpp": implied_dpp,
        "ma_dpp": MA_DPP,
        "verdict": verdict
    }


# ========== 示例：以特斯拉为案例进行PEGR估值 ==========
if __name__ == "__main__":
    # 特斯拉参数（基于2025年末数据，单位：亿美元）
    tsla = PEGRInputs(
        market_cap=15300,      # 1.53万亿美元
        net_income=150,        # 估算净利润约150亿美元
        growth_rate_g1=0.585,  # 市场隐含58.5%复合增长率
        predict_years=5,       # 2026-2030可预测期
        discount_rate=0.12     # 可预测期折现率12%
    )

    result = implied_terminal_dpp(tsla)

    print("=" * 55)
    print("  PEGR估值分析 — 特斯拉（TSLA）")
    print("=" * 55)
    print(f"  当前市值:              ${tsla.market_cap:,.0f}亿")
    print(f"  可预测期贡献现值:       ${result['pv_predict']:,.0f}亿")
    print(f"  可预测期贡献占比:       {result['pv_predict_ratio']:.1%}")
    print(f"  隐含终值定价:          ${result['implied_terminal_value']:,.0f}亿")
    print(f"  隐含终值增长率g2:       {result['implied_g2']:.2%}"
          if result['implied_g2'] else "  隐含终值增长率g2:       N/A")
    print(f"  隐含动态回收期ITV-DPP:  {result['implied_dpp']}年"
          if result['implied_dpp'] else "  隐含动态回收期ITV-DPP:  N/A")
    print(f"  市场平均DPP基准:        {result['ma_dpp']}年")
    print(f"  判断:                  {result['verdict']}")
    print("=" * 55)

"""
AI投资组合风险监控与优化
基于历史模拟法计算VaR，结合分层配置进行组合优化
数据源：使用yfinance获取AI相关标的的历史数据
"""

import numpy as np
import pandas as pd
from scipy.optimize import minimize
from dataclasses import dataclass, field
from typing import List, Dict


@dataclass
class AIAllocation:
    """AI投资分层配置"""
    core: Dict[str, float]      # 核心层：基础设施龙头
    satellite: Dict[str, float] # 卫星层：应用层优质标的
    optional: Dict[str, float]  # 期权层：前沿技术公司

    def all_tickers(self) -> List[str]:
        return list(self.core) + list(self.satellite) + list(self.optional)

    def target_weights(self) -> Dict[str, float]:
        weights = {}
        for ticker, w in self.core.items():
            weights[ticker] = w * 0.45   # 核心层总权重45%
        for ticker, w in self.satellite.items():
            weights[ticker] = w * 0.35   # 卫星层总权重35%
        for ticker, w in self.optional.items():
            weights[ticker] = w * 0.20   # 期权层总权重20%
        return weights


def compute_var(returns: pd.DataFrame,
                weights: np.ndarray,
                confidence: float = 0.95,
                horizon_days: int = 1) -> dict:
    """
    基于历史模拟法计算投资组合VaR

    Args:
        returns: 各资产日收益率DataFrame
        weights: 各资产权重数组
        confidence: 置信水平（默认95%）
        horizon_days: 持有期（默认1天）

    Returns:
        dict: VaR值、CVaR值、年化波动率、最大回撤估计
    """
    # 组合日收益率序列
    port_returns = returns.dot(weights)

    # 历史模拟法VaR
    var_percentile = np.percentile(port_returns, (1 - confidence) * 100)
    var = -var_percentile * np.sqrt(horizon_days)

    # CVaR（条件风险价值）：超过VaR的损失均值
    tail_returns = port_returns[port_returns <= var_percentile]
    cvar = -tail_returns.mean() * np.sqrt(horizon_days) if len(tail_returns) > 0 else var

    # 年化波动率
    annual_vol = port_returns.std() * np.sqrt(252)

    # 最大回撤
    cumulative = (1 + port_returns).cumprod()
    rolling_max = cumulative.cummax()
    drawdown = (cumulative - rolling_max) / rolling_max
    max_drawdown = drawdown.min()

    return {
        "VaR_95": round(var, 4),
        "CVaR_95": round(cvar, 4),
        "annual_volatility": round(annual_vol, 4),
        "max_drawdown": round(max_drawdown, 4),
        "var_interpretation": f"在{confidence:.0%}置信水平下，"
                              f"单日最大预期损失不超过{var:.2%}"
    }


def optimize_portfolio(returns: pd.DataFrame,
                       risk_free_rate: float = 0.04,
                       max_weight: float = 0.30) -> dict:
    """
    均值-方差优化：在给定风险预算下最大化夏普比率

    约束条件：
    - 权重之和为1
    - 单资产权重不超过max_weight
    - 不允许做空
    """
    n = len(returns.columns)
    mean_returns = returns.mean() * 252
    cov_matrix = returns.cov() * 252

    def neg_sharpe(weights):
        port_return = np.dot(weights, mean_returns)
        port_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        return -(port_return - risk_free_rate) / port_vol

    constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
    bounds = tuple((0, max_weight) for _ in range(n))
    init_weights = np.array([1 / n] * n)

    result = minimize(
        neg_sharpe, init_weights,
        method='SLSQP',
        bounds=bounds,
        constraints=constraints,
        options={'maxiter': 1000, 'ftol': 1e-12}
    )

    if not result.success:
        return {"error": f"优化未收敛: {result.message}"}

    optimal_weights = result.x
    port_return = np.dot(optimal_weights, mean_returns)
    port_vol = np.sqrt(np.dot(optimal_weights.T,
                               np.dot(cov_matrix, optimal_weights)))
    sharpe = (port_return - risk_free_rate) / port_vol

    return {
        "weights": dict(zip(returns.columns, optimal_weights.round(4))),
        "expected_annual_return": round(port_return, 4),
        "expected_annual_vol": round(port_vol, 4),
        "sharpe_ratio": round(sharpe, 4),
        "var": compute_var(returns, optimal_weights)
    }


# ========== 示例执行 ==========
if __name__ == "__main__":
    # 模拟AI投资组合的日收益率数据（实际使用时替换为yfinance真实数据）
    np.random.seed(42)
    n_days = 504  # 约2年交易日

    # 模拟四类AI资产的日收益率
    # 基础设施（低波动）、模型层（高波动）、应用层（中波动）、电力（低波动）
    tickers = ["Infra_ETF", "Model_Stock", "App_Stock", "Power_ETF"]
    mus = [0.0008, 0.0012, 0.0009, 0.0006]   # 日预期收益
    sigmas = [0.018, 0.035, 0.025, 0.015]    # 日波动率
    correlation = np.array([
        [1.0, 0.6, 0.5, 0.4],
        [0.6, 1.0, 0.7, 0.3],
        [0.5, 0.7, 1.0, 0.35],
        [0.4, 0.3, 0.35, 1.0]
    ])

    L = np.linalg.cholesky(correlation)
    random_matrix = np.random.normal(0, 1, (n_days, 4))
    correlated = random_matrix @ L.T
    returns_data = correlated * sigmas + mus
    returns_df = pd.DataFrame(returns_data, columns=tickers)

    print("=" * 60)
    print("  AI投资组合风险监控与优化")
    print("=" * 60)

    # 1. 分层配置
    allocation = AIAllocation(
        core={"Infra_ETF": 0.50, "Power_ETF": 0.50},
        satellite={"App_Stock": 1.0},
        optional={"Model_Stock": 1.0}
    )
    target_w = allocation.target_weights()
    weights_array = np.array([target_w[t] for t in tickers])

    print("\n【目标配置权重】")
    for t, w in target_w.items():
        print(f"  {t}: {w:.1%}")

    # 2. 风险价值计算
    var_result = compute_var(returns_df, weights_array, confidence=0.95)
    print("\n【风险价值分析（95%置信度）】")
    for k, v in var_result.items():
        print(f"  {k}: {v}")

    # 3. 均值-方差优化
    opt_result = optimize_portfolio(returns_df, risk_free_rate=0.04)
    print("\n【均值-方差优化结果】")
    print(f"  夏普比率: {opt_result['sharpe_ratio']}")
    print(f"  预期年化收益: {opt_result['expected_annual_return']:.2%}")
    print(f"  预期年化波动: {opt_result['expected_annual_vol']:.2%}")
    print("  优化权重:")
    for t, w in opt_result['weights'].items():
        print(f"    {t}: {w:.1%}")
    print("=" * 60)