aigroup-econ-mcp 1.4.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

econometrics/causal_inference/causal_identification_strategy/regression_discontinuity.py

@@ -0,0 +1,98 @@
+"""
+断点回归设计 (RDD) 实现
+"""
+
+from typing import List, Optional
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field
+from scipy import stats
+import statsmodels.api as sm
+from sklearn.preprocessing import PolynomialFeatures
+
+
+class RDDResult(BaseModel):
+    """断点回归设计结果"""
+    method: str = Field(default="Regression Discontinuity Design", description="使用的因果识别方法")
+    estimate: float = Field(..., description="因果效应估计值")
+    std_error: float = Field(..., description="标准误")
+    t_statistic: float = Field(..., description="t统计量")
+    p_value: float = Field(..., description="p值")
+    confidence_interval: List[float] = Field(..., description="置信区间")
+    n_observations: int = Field(..., description="观测数量")
+    bandwidth: Optional[float] = Field(None, description="使用的带宽")
+    polynomial_order: Optional[int] = Field(None, description="多项式阶数")
+    discontinuity_location: Optional[float] = Field(None, description="断点位置")
+
+
+def regression_discontinuity(
+    running_variable: List[float],
+    outcome: List[float],
+    cutoff: float,
+    bandwidth: Optional[float] = None,
+    polynomial_order: int = 1
+) -> RDDResult:
+    """
+    断点回归设计 (RDD)
+    
+    使用statsmodels实现断点回归设计，评估在断点处的处理效应。
+    
+    Args:
+        running_variable: 运行变量
+        outcome: 结果变量
+        cutoff: 断点值
+        bandwidth: 带宽
+        polynomial_order: 多项式阶数
+        
+    Returns:
+        RDDResult: 断点回归设计结果
+    """
+    # 转换为numpy数组
+    running_array = np.array(running_variable)
+    outcome_array = np.array(outcome)
+    
+    # 如果未指定带宽，使用默认方法计算
+    if bandwidth is None:
+        # 使用数据标准差的四分之一作为默认带宽
+        bandwidth = 0.25 * np.std(running_array)
+    
+    # 筛选带宽内的观测
+    mask = np.abs(running_array - cutoff) <= bandwidth
+    running_local = running_array[mask]
+    outcome_local = outcome_array[mask]
+    
+    # 构造处理变量（运行变量是否大于cutoff）
+    treatment = (running_local >= cutoff).astype(int)
+    
+    # 构造多项式项
+    poly = PolynomialFeatures(degree=polynomial_order, include_bias=False)
+    running_poly = poly.fit_transform(running_local.reshape(-1, 1))
+    
+    # 构建设计矩阵
+    X = np.column_stack([np.ones(len(running_local)), treatment, running_poly])
+    
+    # 使用statsmodels进行OLS回归
+    model = sm.OLS(outcome_local, X)
+    results = model.fit()
+    
+    # 提取处理效应（处理变量系数）
+    coef = results.params[1]  # treatment变量是第2列（索引为1）
+    stderr = results.bse[1]
+    tstat = results.tvalues[1]
+    pval = results.pvalues[1]
+    
+    # 计算置信区间
+    ci_lower = coef - 1.96 * stderr
+    ci_upper = coef + 1.96 * stderr
+    
+    return RDDResult(
+        estimate=float(coef),
+        std_error=float(stderr),
+        t_statistic=float(tstat),
+        p_value=float(pval),
+        confidence_interval=[float(ci_lower), float(ci_upper)],
+        n_observations=len(running_local),
+        bandwidth=bandwidth,
+        polynomial_order=polynomial_order,
+        discontinuity_location=cutoff
+    )

econometrics/causal_inference/causal_identification_strategy/synthetic_control.py

@@ -0,0 +1,111 @@
+"""
+合成控制法实现
+"""
+
+from typing import List, Optional, Dict
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field
+from scipy.optimize import minimize
+from sklearn.linear_model import LinearRegression
+
+
+class SyntheticControlResult(BaseModel):
+    """合成控制法结果"""
+    method: str = Field(default="Synthetic Control Method", description="使用的因果识别方法")
+    treatment_effect: float = Field(..., description="处理效应估计值")
+    synthetic_weights: List[float] = Field(..., description="合成控制权重")
+    n_observations: int = Field(..., description="观测数量")
+    donor_units: List[str] = Field(..., description="对照单元列表")
+    pre_treatment_fit: Dict[str, float] = Field(..., description="处理前拟合度量")
+
+
+def synthetic_control_method(
+    outcome: List[float],
+    treatment_period: int,
+    treated_unit: str,
+    donor_units: List[str],
+    time_periods: List[str]
+) -> SyntheticControlResult:
+    """
+    合成控制法
+    
+    合成控制法通过构造一个"合成"对照单元来评估处理效应，该对照单元是多个未处理单元的加权组合。
+    
+    Args:
+        outcome: 结果变量（所有单元的时序数据）
+        treatment_period: 处理开始的时间期
+        treated_unit: 处理单元名称
+        donor_units: 对照单元名称列表
+        time_periods: 时间期列表
+        
+    Returns:
+        SyntheticControlResult: 合成控制法结果
+    """
+    # 假设数据按单元排列，每个单元连续排列其时间序列
+    n_units = len(donor_units) + 1  # 包括处理单元
+    n_time = len(time_periods)
+    
+    if len(outcome) != n_units * n_time:
+        raise ValueError("结果变量长度应等于单元数乘以时间期数")
+    
+    # 重塑数据为(单元, 时间)矩阵
+    outcome_matrix = np.array(outcome).reshape(n_units, n_time)
+    
+    # 确定处理单元索引
+    treated_idx = 0  # 假设处理单元是第一个
+    
+    # 提取处理前时期的数据
+    pre_treatment_periods = treatment_period
+    treated_pre = outcome_matrix[treated_idx, :pre_treatment_periods]
+    donors_pre = outcome_matrix[1:, :pre_treatment_periods]  # 排除处理单元
+    
+    # 定义优化目标函数（最小化均方预测误差）
+    def objective(weights):
+        synthetic = donors_pre.T @ weights
+        mse = np.mean((treated_pre - synthetic) ** 2)
+        return mse
+    
+    # 约束条件：权重非负且和为1
+    constraints = [
+        {"type": "eq", "fun": lambda w: np.sum(w) - 1}  # 权重和为1
+    ]
+    bounds = [(0, 1) for _ in range(len(donor_units))]  # 权重在[0,1]之间
+    
+    # 初始权重
+    initial_weights = np.ones(len(donor_units)) / len(donor_units)
+    
+    # 优化求解
+    result = minimize(objective, initial_weights, method='SLSQP', 
+                     bounds=bounds, constraints=constraints)
+    
+    optimal_weights = result.x
+    
+    # 计算合成对照单元的结果 - 修复矩阵乘法维度问题
+    # outcome_matrix[1:] 形状: (n_units-1, n_time)
+    # optimal_weights 形状: (n_units-1,)
+    # 我们需要 (n_time, n_units-1) @ (n_units-1,) = (n_time,)
+    synthetic_control = outcome_matrix[1:].T @ optimal_weights  # 所有时期
+    
+    # 计算处理效应（处理后时期）
+    post_treatment_outcome = outcome_matrix[treated_idx, treatment_period:]
+    post_treatment_synthetic = synthetic_control[treatment_period:]
+    treatment_effect = np.mean(post_treatment_outcome - post_treatment_synthetic)
+    
+    # 计算处理前拟合度量
+    pre_treatment_synthetic = synthetic_control[:treatment_period]
+    pre_treatment_r2 = 1 - np.sum((treated_pre - pre_treatment_synthetic) ** 2) / \
+                       np.sum((treated_pre - np.mean(treated_pre)) ** 2)
+    
+    pre_treatment_fit = {
+        "R-squared": float(pre_treatment_r2),
+        "RMSE": float(np.sqrt(np.mean((treated_pre - pre_treatment_synthetic) ** 2)))
+    }
+    
+    return SyntheticControlResult(
+        treatment_effect=float(treatment_effect),
+        synthetic_weights=optimal_weights.tolist(),
+        n_observations=len(outcome),
+        donor_units=donor_units,
+        pre_treatment_fit=pre_treatment_fit
+    )

econometrics/causal_inference/causal_identification_strategy/triple_difference.py

@@ -0,0 +1,86 @@
+"""
+三重差分法 (DDD) 实现
+"""
+
+from typing import List, Optional
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field
+import statsmodels.api as sm
+from scipy import stats
+
+
+class TripeDifferenceResult(BaseModel):
+    """三重差分法结果"""
+    method: str = Field(default="Triple Difference", description="使用的因果识别方法")
+    estimate: float = Field(..., description="因果效应估计值")
+    std_error: float = Field(..., description="标准误")
+    t_statistic: float = Field(..., description="t统计量")
+    p_value: float = Field(..., description="p值")
+    confidence_interval: List[float] = Field(..., description="置信区间")
+    n_observations: int = Field(..., description="观测数量")
+
+
+def triple_difference(
+    outcome: List[float],
+    treatment_group: List[int],
+    time_period: List[int],
+    cohort_group: List[int]
+) -> TripeDifferenceResult:
+    """
+    三重差分法 (DDD)
+    
+    三重差分法通过引入第三个维度（如不同的队列组）来进一步控制混杂因素，
+    提供比双重差分法更强的因果识别能力。
+    
+    Args:
+        outcome: 结果变量
+        treatment_group: 处理组虚拟变量 (0/1)
+        time_period: 时间虚拟变量 (0/1)
+        cohort_group: 队列组虚拟变量 (0/1)
+        
+    Returns:
+        TripeDifferenceResult: 三重差分法结果
+    """
+    # 构建数据
+    df = pd.DataFrame({
+        'outcome': outcome,
+        'treatment': treatment_group,
+        'time': time_period,
+        'cohort': cohort_group
+    })
+    
+    # 构建交互项
+    df['treatment_time'] = df['treatment'] * df['time']
+    df['treatment_cohort'] = df['treatment'] * df['cohort']
+    df['time_cohort'] = df['time'] * df['cohort']
+    df['treatment_time_cohort'] = df['treatment'] * df['time'] * df['cohort']
+    
+    # 构建回归设计矩阵
+    X_vars = ['treatment', 'time', 'cohort', 'treatment_time', 'treatment_cohort', 'time_cohort', 'treatment_time_cohort']
+    X = df[X_vars]
+    X = sm.add_constant(X)  # 添加常数项
+    y = df['outcome']
+    
+    # OLS回归
+    model = sm.OLS(y, X)
+    results = model.fit()
+    
+    # 提取三重差分估计结果（三重交互项系数）
+    coef = results.params['treatment_time_cohort']
+    stderr = results.bse['treatment_time_cohort']
+    tstat = results.tvalues['treatment_time_cohort']
+    pval = results.pvalues['treatment_time_cohort']
+    
+    # 计算置信区间
+    ci_lower = coef - 1.96 * stderr
+    ci_upper = coef + 1.96 * stderr
+    
+    return TripeDifferenceResult(
+        estimate=float(coef),
+        std_error=float(stderr),
+        t_statistic=float(tstat),
+        p_value=float(pval),
+        confidence_interval=[float(ci_lower), float(ci_upper)],
+        n_observations=len(df)
+    )

econometrics/distribution_analysis/__init__.py

@@ -0,0 +1,28 @@
+"""
+分布分析与分解方法模块
+分析因变量的条件分布特征并进行各种分解分析
+"""
+
+from .oaxaca_blinder import (
+    oaxaca_blinder_decomposition,
+    OaxacaResult
+)
+
+from .variance_decomposition import (
+    variance_decomposition,
+    VarianceDecompositionResult
+)
+
+from .time_series_decomposition import (
+    time_series_decomposition,
+    TimeSeriesDecompositionResult
+)
+
+__all__ = [
+    'oaxaca_blinder_decomposition',
+    'OaxacaResult',
+    'variance_decomposition',
+    'VarianceDecompositionResult',
+    'time_series_decomposition',
+    'TimeSeriesDecompositionResult'
+]

econometrics/distribution_analysis/oaxaca_blinder.py

@@ -0,0 +1,184 @@
+"""
+Oaxaca-Blinder分解
+用于分解两组之间的平均差异（如工资差距）
+基于 statsmodels 和自定义实现
+"""
+
+from typing import List, Optional, Tuple
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    import statsmodels.api as sm
+    STATSMODELS_AVAILABLE = True
+except ImportError:
+    STATSMODELS_AVAILABLE = False
+    sm = None
+
+
+class OaxacaResult(BaseModel):
+    """Oaxaca-Blinder分解结果"""
+    total_difference: float = Field(..., description="总差异")
+    explained_part: float = Field(..., description="可解释部分（禀赋效应）")
+    unexplained_part: float = Field(..., description="不可解释部分（系数效应）")
+    explained_pct: float = Field(..., description="可解释部分百分比")
+    unexplained_pct: float = Field(..., description="不可解释部分百分比")
+    group_a_mean: float = Field(..., description="A组平均值")
+    group_b_mean: float = Field(..., description="B组平均值")
+    group_a_coefficients: List[float] = Field(..., description="A组回归系数")
+    group_b_coefficients: List[float] = Field(..., description="B组回归系数")
+    detailed_explained: List[float] = Field(..., description="各变量的可解释部分")
+    detailed_unexplained: List[float] = Field(..., description="各变量的不可解释部分")
+    feature_names: List[str] = Field(..., description="特征名称")
+    n_obs_a: int = Field(..., description="A组观测数")
+    n_obs_b: int = Field(..., description="B组观测数")
+    summary: str = Field(..., description="摘要信息")
+
+
+def oaxaca_blinder_decomposition(
+    y_a: List[float],
+    x_a: List[List[float]],
+    y_b: List[float],
+    x_b: List[List[float]],
+    feature_names: Optional[List[str]] = None,
+    weight_matrix: str = "pooled"
+) -> OaxacaResult:
+    """
+    Oaxaca-Blinder分解
+    分解两组之间的平均差异为可解释部分和不可解释部分
+    
+    Args:
+        y_a: A组因变量（如男性工资）
+        x_a: A组自变量
+        y_b: B组因变量（如女性工资）
+        x_b: B组自变量
+        feature_names: 特征名称
+        weight_matrix: 权重矩阵类型 - "pooled"(pooled权重), "group_a", "group_b"
+        
+    Returns:
+        OaxacaResult: Oaxaca-Blinder分解结果
+        
+    Raises:
+        ImportError: statsmodels库未安装
+        ValueError: 输入数据无效
+    """
+    if not STATSMODELS_AVAILABLE:
+        raise ImportError("statsmodels库未安装。请运行: pip install statsmodels")
+    
+    # 输入验证
+    if not y_a or not x_a or not y_b or not x_b:
+        raise ValueError("所有输入数据不能为空")
+    
+    # 数据准备
+    y_a_arr = np.array(y_a, dtype=np.float64)
+    X_a_arr = np.array(x_a, dtype=np.float64)
+    y_b_arr = np.array(y_b, dtype=np.float64)
+    X_b_arr = np.array(x_b, dtype=np.float64)
+    
+    # 确保X是二维数组
+    if X_a_arr.ndim == 1:
+        X_a_arr = X_a_arr.reshape(-1, 1)
+    if X_b_arr.ndim == 1:
+        X_b_arr = X_b_arr.reshape(-1, 1)
+    
+    n_a = len(y_a_arr)
+    n_b = len(y_b_arr)
+    k = X_a_arr.shape[1]
+    
+    # 数据验证
+    if X_a_arr.shape[1] != X_b_arr.shape[1]:
+        raise ValueError("两组的自变量数量必须相同")
+    
+    # 添加常数项
+    X_a_const = sm.add_constant(X_a_arr)
+    X_b_const = sm.add_constant(X_b_arr)
+    
+    # 特征名称
+    if feature_names is None:
+        feature_names = [f"X{i+1}" for i in range(k)]
+    all_feature_names = ["const"] + feature_names
+    
+    # 对两组分别进行OLS回归
+    model_a = sm.OLS(y_a_arr, X_a_const).fit()
+    model_b = sm.OLS(y_b_arr, X_b_const).fit()
+    
+    # 提取系数
+    beta_a = model_a.params
+    beta_b = model_b.params
+    
+    # 计算两组的平均特征值
+    X_a_mean = X_a_const.mean(axis=0)
+    X_b_mean = X_b_const.mean(axis=0)
+    
+    # 计算两组的平均因变量
+    y_a_mean = float(y_a_arr.mean())
+    y_b_mean = float(y_b_arr.mean())
+    
+    # 总差异
+    total_diff = y_a_mean - y_b_mean
+    
+    # 根据权重矩阵选择参考系数
+    if weight_matrix == "pooled":
+        # 使用pooled回归的系数作为参考
+        y_pooled = np.concatenate([y_a_arr, y_b_arr])
+        X_pooled = np.vstack([X_a_const, X_b_const])
+        model_pooled = sm.OLS(y_pooled, X_pooled).fit()
+        beta_ref = model_pooled.params
+    elif weight_matrix == "group_a":
+        beta_ref = beta_a
+    elif weight_matrix == "group_b":
+        beta_ref = beta_b
+    else:
+        raise ValueError(f"不支持的权重矩阵类型: {weight_matrix}")
+    
+    # Oaxaca分解
+    # 可解释部分（禀赋效应）: (X̄ₐ - X̄ᵦ)' β*
+    explained = (X_a_mean - X_b_mean) @ beta_ref
+    
+    # 不可解释部分（系数效应）: X̄ₐ'(βₐ - β*) + X̄ᵦ'(β* - βᵦ)
+    unexplained = X_a_mean @ (beta_a - beta_ref) + X_b_mean @ (beta_ref - beta_b)
+    
+    # 详细分解（每个变量的贡献）
+    detailed_explained = ((X_a_mean - X_b_mean) * beta_ref).tolist()
+    detailed_unexplained = (
+        X_a_mean * (beta_a - beta_ref) + X_b_mean * (beta_ref - beta_b)
+    ).tolist()
+    
+    # 百分比
+    explained_pct = (explained / total_diff * 100) if total_diff != 0 else 0.0
+    unexplained_pct = (unexplained / total_diff * 100) if total_diff != 0 else 0.0
+    
+    # 生成摘要
+    summary = f"""Oaxaca-Blinder分解:
+- 总差异: {total_diff:.4f}
+  - A组平均: {y_a_mean:.4f} (n={n_a})
+  - B组平均: {y_b_mean:.4f} (n={n_b})
+
+分解结果:
+- 可解释部分（禀赋效应）: {explained:.4f} ({explained_pct:.1f}%)
+- 不可解释部分（系数效应）: {unexplained:.4f} ({unexplained_pct:.1f}%)
+
+各变量贡献:
+"""
+    for i, name in enumerate(all_feature_names):
+        summary += f"  {name}:\n"
+        summary += f"    - 禀赋效应: {detailed_explained[i]:.4f}\n"
+        summary += f"    - 系数效应: {detailed_unexplained[i]:.4f}\n"
+    
+    return OaxacaResult(
+        total_difference=float(total_diff),
+        explained_part=float(explained),
+        unexplained_part=float(unexplained),
+        explained_pct=float(explained_pct),
+        unexplained_pct=float(unexplained_pct),
+        group_a_mean=y_a_mean,
+        group_b_mean=y_b_mean,
+        group_a_coefficients=beta_a.tolist(),
+        group_b_coefficients=beta_b.tolist(),
+        detailed_explained=detailed_explained,
+        detailed_unexplained=detailed_unexplained,
+        feature_names=all_feature_names,
+        n_obs_a=n_a,
+        n_obs_b=n_b,
+        summary=summary
+    )

econometrics/distribution_analysis/time_series_decomposition.py

@@ -0,0 +1,152 @@
+"""
+时间序列分解
+将时间序列分解为趋势、季节和随机成分
+基于 statsmodels 实现
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from statsmodels.tsa.seasonal import seasonal_decompose, STL
+    STATSMODELS_AVAILABLE = True
+except ImportError:
+    STATSMODELS_AVAILABLE = False
+    seasonal_decompose = None
+    STL = None
+
+
+class TimeSeriesDecompositionResult(BaseModel):
+    """时间序列分解结果"""
+    trend: List[float] = Field(..., description="趋势成分")
+    seasonal: List[float] = Field(..., description="季节成分")
+    residual: List[float] = Field(..., description="随机成分")
+    observed: List[float] = Field(..., description="原始观测值")
+    decomposition_type: str = Field(..., description="分解类型（加法/乘法）")
+    method: str = Field(..., description="分解方法")
+    period: int = Field(..., description="季节周期")
+    trend_strength: float = Field(..., description="趋势强度")
+    seasonal_strength: float = Field(..., description="季节强度")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def time_series_decomposition(
+    data: List[float],
+    period: int = 12,
+    model: str = "additive",
+    method: str = "classical",
+    extrapolate_trend: str = "freq"
+) -> TimeSeriesDecompositionResult:
+    """
+    时间序列分解
+    
+    Args:
+        data: 时间序列数据
+        period: 季节周期（如12表示月度数据的年周期）
+        model: 分解模型类型 - "additive"(加法模型) 或 "multiplicative"(乘法模型)
+        method: 分解方法 - "classical"(经典分解) 或 "stl"(STL分解)
+        extrapolate_trend: 趋势外推方法
+        
+    Returns:
+        TimeSeriesDecompositionResult: 时间序列分解结果
+        
+    Raises:
+        ImportError: statsmodels库未安装
+        ValueError: 输入数据无效
+    """
+    if not STATSMODELS_AVAILABLE:
+        raise ImportError("statsmodels库未安装。请运行: pip install statsmodels")
+    
+    # 输入验证
+    if not data:
+        raise ValueError("data不能为空")
+    
+    if len(data) < 2 * period:
+        raise ValueError(f"数据点数({len(data)})应至少为季节周期({period})的2倍")
+    
+    # 数据准备
+    y = np.array(data, dtype=np.float64)
+    n = len(y)
+    
+    # 检查缺失值
+    if np.isnan(y).any():
+        raise ValueError("数据中包含缺失值")
+    
+    # 执行分解
+    if method == "classical":
+        # 使用经典分解方法
+        decomposition = seasonal_decompose(
+            y,
+            model=model,
+            period=period,
+            extrapolate_trend=extrapolate_trend
+        )
+    elif method == "stl":
+        # 使用STL分解（仅支持加法模型）
+        if model != "additive":
+            raise ValueError("STL分解仅支持加法模型")
+        decomposition = STL(y, period=period).fit()
+    else:
+        raise ValueError(f"不支持的分解方法: {method}")
+    
+    # 提取成分
+    trend = decomposition.trend
+    seasonal = decomposition.seasonal
+    residual = decomposition.resid
+    
+    # 处理NaN值（在趋势计算中可能产生）
+    # 使用线性插值填充
+    if np.isnan(trend).any():
+        mask = ~np.isnan(trend)
+        indices = np.arange(len(trend))
+        trend = np.interp(indices, indices[mask], trend[mask])
+    
+    # 计算趋势和季节强度
+    # 趋势强度 = 1 - Var(残差) / Var(去季节化序列)
+    deseasonalized = y - seasonal
+    var_resid = np.var(residual[~np.isnan(residual)])
+    var_deseas = np.var(deseasonalized[~np.isnan(deseasonalized)])
+    trend_strength = 1 - (var_resid / var_deseas) if var_deseas > 0 else 0.0
+    trend_strength = max(0.0, min(1.0, trend_strength))
+    
+    # 季节强度 = 1 - Var(残差) / Var(去趋势化序列)
+    detrended = y - trend
+    var_detrend = np.var(detrended[~np.isnan(detrended)])
+    seasonal_strength = 1 - (var_resid / var_detrend) if var_detrend > 0 else 0.0
+    seasonal_strength = max(0.0, min(1.0, seasonal_strength))
+    
+    # 生成摘要
+    summary = f"""时间序列分解:
+- 观测数量: {n}
+- 季节周期: {period}
+- 分解模型: {model}
+- 分解方法: {method}
+
+成分方差:
+- 趋势方差: {np.var(trend[~np.isnan(trend)]):.4f}
+- 季节方差: {np.var(seasonal[~np.isnan(seasonal)]):.4f}
+- 残差方差: {var_resid:.4f}
+
+强度指标:
+- 趋势强度: {trend_strength:.4f} ({'强' if trend_strength > 0.6 else '中' if trend_strength > 0.3 else '弱'})
+- 季节强度: {seasonal_strength:.4f} ({'强' if seasonal_strength > 0.6 else '中' if seasonal_strength > 0.3 else '弱'})
+
+解释:
+- {model}模型: y = {'趋势 + 季节 + 随机' if model == 'additive' else '趋势 × 季节 × 随机'}
+"""
+    
+    return TimeSeriesDecompositionResult(
+        trend=trend.tolist(),
+        seasonal=seasonal.tolist(),
+        residual=residual.tolist(),
+        observed=y.tolist(),
+        decomposition_type=model,
+        method=method,
+        period=period,
+        trend_strength=float(trend_strength),
+        seasonal_strength=float(seasonal_strength),
+        n_observations=n,
+        summary=summary
+    )