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

econometrics/distribution_analysis/variance_decomposition.py

@@ -0,0 +1,179 @@
+"""
+方差分解 (Variance Decomposition / ANOVA)
+基于 scipy 和 statsmodels 实现
+"""
+
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from scipy import stats
+    import statsmodels.api as sm
+    from statsmodels.formula.api import ols
+    SCIPY_AVAILABLE = True
+except ImportError:
+    SCIPY_AVAILABLE = False
+    stats = None
+    sm = None
+
+
+class VarianceDecompositionResult(BaseModel):
+    """方差分解结果"""
+    total_variance: float = Field(..., description="总方差")
+    between_group_variance: float = Field(..., description="组间方差")
+    within_group_variance: float = Field(..., description="组内方差")
+    f_statistic: float = Field(..., description="F统计量")
+    p_value: float = Field(..., description="P值")
+    eta_squared: float = Field(..., description="Eta平方（效应量）")
+    omega_squared: float = Field(..., description="Omega平方（偏效应量）")
+    group_means: Dict[str, float] = Field(..., description="各组均值")
+    group_variances: Dict[str, float] = Field(..., description="各组方差")
+    group_sizes: Dict[str, int] = Field(..., description="各组样本量")
+    n_groups: int = Field(..., description="组数")
+    total_n: int = Field(..., description="总样本量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def variance_decomposition(
+    values: List[float],
+    groups: List[str],
+    group_names: Optional[List[str]] = None
+) -> VarianceDecompositionResult:
+    """
+    方差分解 / 单因素ANOVA
+    
+    Args:
+        values: 观测值列表
+        groups: 组别标识列表
+        group_names: 组名称映射
+        
+    Returns:
+        VarianceDecompositionResult: 方差分解结果
+        
+    Raises:
+        ImportError: scipy库未安装
+        ValueError: 输入数据无效
+    """
+    if not SCIPY_AVAILABLE:
+        raise ImportError("scipy和statsmodels库未安装。请运行: pip install scipy statsmodels")
+    
+    # 输入验证
+    if not values or not groups:
+        raise ValueError("values和groups不能为空")
+    
+    if len(values) != len(groups):
+        raise ValueError(f"values长度({len(values)})与groups长度({len(groups)})不一致")
+    
+    # 数据准备
+    y = np.array(values, dtype=np.float64)
+    g = np.array(groups)
+    
+    # 获取唯一组别
+    unique_groups = np.unique(g)
+    n_groups = len(unique_groups)
+    
+    if n_groups < 2:
+        raise ValueError("至少需要2个组进行方差分解")
+    
+    # 计算总体统计量
+    grand_mean = y.mean()
+    total_variance = y.var(ddof=1)
+    total_n = len(y)
+    
+    # 计算各组统计量
+    group_means = {}
+    group_variances = {}
+    group_sizes = {}
+    
+    # 按组分组数据
+    groups_data = []
+    for group_id in unique_groups:
+        mask = g == group_id
+        group_data = y[mask]
+        groups_data.append(group_data)
+        
+        group_key = str(group_id)
+        group_means[group_key] = float(group_data.mean())
+        group_variances[group_key] = float(group_data.var(ddof=1))
+        group_sizes[group_key] = int(len(group_data))
+    
+    # 执行单因素ANOVA
+    f_stat, p_value = stats.f_oneway(*groups_data)
+    
+    # 计算组间方差和组内方差
+    # SS_between = Σnᵢ(ȳᵢ - ȳ)²
+    ss_between = sum(
+        group_sizes[str(gid)] * (group_means[str(gid)] - grand_mean)**2 
+        for gid in unique_groups
+    )
+    
+    # SS_within = Σ(nᵢ - 1)sᵢ²
+    ss_within = sum(
+        (group_sizes[str(gid)] - 1) * group_variances[str(gid)] 
+        for gid in unique_groups
+    )
+   
+    # SS_total
+    ss_total = (total_n - 1) * total_variance
+    
+    # 自由度
+    df_between = n_groups - 1
+    df_within = total_n - n_groups
+    
+    # 均方
+    ms_between = ss_between / df_between
+    ms_within = ss_within / df_within
+    
+    # 组间方差和组内方差（作为总方差的比例）
+    between_group_var = ss_between / (total_n - 1)
+    within_group_var = ss_within / (total_n - 1)
+    
+    # 效应量
+    # Eta平方 = SS_between / SS_total
+    eta_squared = ss_between / ss_total if ss_total > 0 else 0.0
+    
+    # Omega平方（偏效应量）
+    omega_squared = (ss_between - df_between * ms_within) / (ss_total + ms_within)
+    omega_squared = max(0.0, omega_squared)  # 确保非负
+    
+    # 生成摘要
+    summary = f"""方差分解 (ANOVA) 分析:
+- 总样本量: {total_n}
+- 组数: {n_groups}
+- 总方差: {total_variance:.4f}
+
+方差分解:
+- 组间方差: {between_group_var:.4f} ({eta_squared*100:.1f}%)
+- 组内方差: {within_group_var:.4f} ({(1-eta_squared)*100:.1f}%)
+
+F检验:
+- F统计量: {f_stat:.4f}
+- P值: {p_value:.4f}
+- 结论: {'组间差异显著' if p_value < 0.05 else '组间差异不显著'}
+
+效应量:
+- Eta²: {eta_squared:.4f}
+- Omega²: {omega_squared:.4f}
+
+各组均值:
+"""
+    for gid in unique_groups:
+        gkey = str(gid)
+        summary += f"  {gkey}: {group_means[gkey]:.4f} (n={group_sizes[gkey]}, s²={group_variances[gkey]:.4f})\n"
+    
+    return VarianceDecompositionResult(
+        total_variance=float(total_variance),
+        between_group_variance=float(between_group_var),
+        within_group_variance=float(within_group_var),
+        f_statistic=float(f_stat),
+        p_value=float(p_value),
+        eta_squared=float(eta_squared),
+        omega_squared=float(omega_squared),
+        group_means=group_means,
+        group_variances=group_variances,
+        group_sizes=group_sizes,
+        n_groups=n_groups,
+        total_n=total_n,
+        summary=summary
+    )

econometrics/missing_data/__init__.py

@@ -0,0 +1,18 @@
+"""
+缺失数据处理模块
+提供多种插补和处理缺失数据的方法
+"""
+
+from .imputation_methods import (
+    simple_imputation,
+    multiple_imputation,
+    SimpleImputationResult,
+    MultipleImputationResult
+)
+
+__all__ = [
+    'simple_imputation',
+    'multiple_imputation',
+    'SimpleImputationResult',
+    'MultipleImputationResult'
+]

econometrics/missing_data/imputation_methods.py

@@ -0,0 +1,219 @@
+"""
+缺失数据插补方法
+基于 sklearn.impute 实现
+"""
+
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from sklearn.impute import SimpleImputer, IterativeImputer
+    from sklearn.experimental import enable_iterative_imputer
+    SKLEARN_AVAILABLE = True
+except ImportError:
+    SKLEARN_AVAILABLE = False
+    SimpleImputer = None
+    IterativeImputer = None
+
+
+class SimpleImputationResult(BaseModel):
+    """简单插补结果"""
+    imputed_data: List[List[float]] = Field(..., description="插补后的数据")
+    missing_mask: List[List[bool]] = Field(..., description="缺失值掩码")
+    n_missing: int = Field(..., description="缺失值总数")
+    missing_rate: float = Field(..., description="缺失率")
+    imputation_method: str = Field(..., description="插补方法")
+    fill_values: List[float] = Field(..., description="填充值（每列）")
+    n_observations: int = Field(..., description="观测数量")
+    n_features: int = Field(..., description="特征数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+class MultipleImputationResult(BaseModel):
+    """多重插补结果"""
+    imputed_datasets: List[List[List[float]]] = Field(..., description="多个插补数据集")
+    n_imputations: int = Field(..., description="插补次数")
+    missing_mask: List[List[bool]] = Field(..., description="缺失值掩码")
+    n_missing: int = Field(..., description="缺失值总数")
+    missing_rate: float = Field(..., description="缺失率")
+    convergence_info: Dict = Field(..., description="收敛信息")
+    n_observations: int = Field(..., description="观测数量")
+    n_features: int = Field(..., description="特征数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def simple_imputation(
+    data: List[List[float]],
+    strategy: str = "mean",
+    fill_value: Optional[float] = None
+) -> SimpleImputationResult:
+    """
+    简单插补方法
+    
+    Args:
+        data: 含缺失值的数据（二维列表，NaN表示缺失）
+        strategy: 插补策略 - "mean"(均值), "median"(中位数), 
+                  "most_frequent"(众数), "constant"(常数)
+        fill_value: 当strategy="constant"时使用的填充值
+        
+    Returns:
+        SimpleImputationResult: 简单插补结果
+        
+    Raises:
+        ImportError: sklearn库未安装
+        ValueError: 输入数据无效
+    """
+    if not SKLEARN_AVAILABLE:
+        raise ImportError("sklearn库未安装。请运行: pip install scikit-learn")
+    
+    # 输入验证
+    if not data:
+        raise ValueError("data不能为空")
+    
+    # 转换为numpy数组
+    X = np.array(data, dtype=np.float64)
+    
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n, k = X.shape
+    
+    # 创建缺失值掩码
+    missing_mask = np.isnan(X)
+    n_missing = int(missing_mask.sum())
+    missing_rate = float(n_missing / (n * k))
+    
+    # 简单插补
+    if strategy == "constant":
+        if fill_value is None:
+            fill_value = 0.0
+        imputer = SimpleImputer(strategy=strategy, fill_value=fill_value)
+    else:
+        imputer = SimpleImputer(strategy=strategy)
+    
+    # 执行插补
+    X_imputed = imputer.fit_transform(X)
+    
+    # 填充值
+    fill_values = imputer.statistics_.tolist()
+    
+    # 生成摘要
+    summary = f"""简单插补:
+- 观测数量: {n}
+- 特征数量: {k}
+- 缺失值数量: {n_missing}
+- 缺失率: {missing_rate*100:.2f}%
+- 插补策略: {strategy}
+
+各列填充值:
+"""
+    for i, val in enumerate(fill_values):
+        col_missing = int(missing_mask[:, i].sum())
+        summary += f"  列{i+1}: {val:.4f} (缺失{col_missing}个)\n"
+    
+    return SimpleImputationResult(
+        imputed_data=X_imputed.tolist(),
+        missing_mask=missing_mask.tolist(),
+        n_missing=n_missing,
+        missing_rate=missing_rate,
+        imputation_method=strategy,
+        fill_values=fill_values,
+        n_observations=n,
+        n_features=k,
+        summary=summary
+    )
+
+
+def multiple_imputation(
+    data: List[List[float]],
+    n_imputations: int = 5,
+    max_iter: int = 10,
+    random_state: Optional[int] = None
+) -> MultipleImputationResult:
+    """
+    多重插补 (MICE - Multivariate Imputation by Chained Equations)
+    
+    Args:
+        data: 含缺失值的数据
+        n_imputations: 生成的插补数据集数量
+        max_iter: 最大迭代次数
+        random_state: 随机种子
+        
+    Returns:
+        MultipleImputationResult: 多重插补结果
+    """
+    if not SKLEARN_AVAILABLE:
+        raise ImportError("sklearn库未安装")
+    
+    # 输入验证
+    if not data:
+        raise ValueError("data不能为空")
+    
+    X = np.array(data, dtype=np.float64)
+    
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n, k = X.shape
+    
+    # 缺失值统计
+    missing_mask = np.isnan(X)
+    n_missing = int(missing_mask.sum())
+    missing_rate = float(n_missing / (n * k))
+    
+    # 执行多重插补
+    imputed_datasets = []
+    convergence_info = {"iterations": [], "converged": []}
+    
+    for i in range(n_imputations):
+        # 设置随机种子
+        seed = random_state + i if random_state is not None else None
+        
+        # 创建迭代插补器
+        imputer = IterativeImputer(
+            max_iter=max_iter,
+            random_state=seed,
+            verbose=0
+        )
+        
+        # 执行插补
+        X_imputed = imputer.fit_transform(X)
+        imputed_datasets.append(X_imputed.tolist())
+        
+        # 记录收敛信息
+        convergence_info["iterations"].append(imputer.n_iter_)
+        convergence_info["converged"].append(imputer.n_iter_ < max_iter)
+    
+    # 计算平均收敛迭代数
+    avg_iter = np.mean(convergence_info["iterations"])
+    n_converged = sum(convergence_info["converged"])
+    
+    # 生成摘要
+    summary = f"""多重插补 (MICE):
+- 观测数量: {n}
+- 特征数量: {k}
+- 缺失值数量: {n_missing}
+- 缺失率: {missing_rate*100:.2f}%
+- 插补次数: {n_imputations}
+- 最大迭代: {max_iter}
+
+收敛信息:
+- 平均迭代数: {avg_iter:.1f}
+- 收敛数据集: {n_converged}/{n_imputations}
+
+说明: 生成{n_imputations}个完整的插补数据集，
+可用于后续分析并合并结果（Rubin规则）
+"""
+    
+    return MultipleImputationResult(
+        imputed_datasets=imputed_datasets,
+        n_imputations=n_imputations,
+        missing_mask=missing_mask.tolist(),
+        n_missing=n_missing,
+        missing_rate=missing_rate,
+        convergence_info=convergence_info,
+        n_observations=n,
+        n_features=k,
+        summary=summary
+    )

econometrics/nonparametric/__init__.py

@@ -0,0 +1,35 @@
+"""
+非参数与半参数方法模块
+放宽函数形式的线性或参数化假设
+"""
+
+from .kernel_regression import (
+    kernel_regression,
+    KernelRegressionResult
+)
+
+from .quantile_regression import (
+    quantile_regression,
+    QuantileRegressionResult
+)
+
+from .spline_regression import (
+    spline_regression,
+    SplineRegressionResult
+)
+
+from .gam_model import (
+    gam_model,
+    GAMResult
+)
+
+__all__ = [
+    'kernel_regression',
+    'KernelRegressionResult',
+    'quantile_regression',
+    'QuantileRegressionResult',
+    'spline_regression',
+    'SplineRegressionResult',
+    'gam_model',
+    'GAMResult'
+]

econometrics/nonparametric/gam_model.py

@@ -0,0 +1,117 @@
+"""
+广义可加模型 (Generalized Additive Model - GAM)
+基于 pygam 库实现
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from pygam import LinearGAM, LogisticGAM, s, f
+    PYGAM_AVAILABLE = True
+except ImportError:
+    PYGAM_AVAILABLE = False
+    LinearGAM = None
+
+
+class GAMResult(BaseModel):
+    """GAM模型结果"""
+    fitted_values: List[float] = Field(..., description="拟合值")
+    residuals: List[float] = Field(..., description="残差")
+    deviance: float = Field(..., description="偏差")
+    aic: float = Field(..., description="AIC信息准则")
+    aicc: float = Field(..., description="AICc信息准则")
+    r_squared: float = Field(..., description="伪R²")
+    n_splines: List[int] = Field(..., description="每个特征的样条数")
+    problem_type: str = Field(..., description="问题类型")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def gam_model(
+    y_data: List[float],
+    x_data: List[List[float]],
+    problem_type: str = "regression",
+    n_splines: int = 10,
+    lam: float = 0.6
+) -> GAMResult:
+    """
+    广义可加模型
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（二维列表）
+        problem_type: 问题类型 - "regression"(回归) 或 "classification"(分类)
+        n_splines: 每个特征的样条数
+        lam: 平滑参数（lambda）
+        
+    Returns:
+        GAMResult: GAM模型结果
+    """
+    if not PYGAM_AVAILABLE:
+        raise ImportError("pygam库未安装。请运行: pip install pygam")
+    
+    # 数据准备
+    y = np.array(y_data, dtype=np.float64)
+    X = np.array(x_data, dtype=np.float64)
+    
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n, k = X.shape
+    
+    # 创建GAM模型
+    if problem_type == "regression":
+        gam = LinearGAM(s(0, n_splines=n_splines, lam=lam))
+        for i in range(1, k):
+            gam = LinearGAM(s(i, n_splines=n_splines, lam=lam))
+    elif problem_type == "classification":
+        gam = LogisticGAM(s(0, n_splines=n_splines, lam=lam))
+    else:
+        raise ValueError(f"不支持的问题类型: {problem_type}")
+    
+    # 拟合模型
+    gam.fit(X, y)
+    
+    # 拟合值
+    y_pred = gam.predict(X)
+    
+    # 残差
+    residuals = y - y_pred
+    
+    # 模型统计量
+    deviance = float(gam.statistics_['deviance'])
+    aic = float(gam.statistics_['AIC'])
+    aicc = float(gam.statistics_['AICc'])
+    
+    # 伪R²
+    r_squared = float(gam.statistics_['pseudo_r2']['explained_deviance'])
+    
+    # 样条数信息
+    n_splines_list = [n_splines] * k
+    
+    summary = f"""广义可加模型 (GAM):
+- 观测数量: {n}
+- 特征数量: {k}
+- 问题类型: {problem_type}
+- 样条数: {n_splines}
+- 平滑参数: {lam}
+- 偏差: {deviance:.4f}
+- AIC: {aic:.2f}
+- AICc: {aicc:.2f}
+- 伪R²: {r_squared:.4f}
+"""
+    
+    return GAMResult(
+        fitted_values=y_pred.tolist(),
+        residuals=residuals.tolist(),
+        deviance=deviance,
+        aic=aic,
+        aicc=aicc,
+        r_squared=r_squared,
+        n_splines=n_splines_list,
+        problem_type=problem_type,
+        n_observations=n,
+        summary=summary
+    )