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

econometrics/specific_data_modeling/micro_discrete_limited_data/limited_dependent_variable_models.py

@@ -0,0 +1,282 @@
+"""
+受限因变量模型模块
+基于statsmodels等现有库实现
+"""
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+try:
+    import statsmodels.api as sm
+    from statsmodels.regression.linear_model import OLS
+    HAS_STATSMODELS = True
+except ImportError:
+    HAS_STATSMODELS = False
+    OLS = None
+
+try:
+    from statsmodels.base.model import GenericLikelihoodModel
+    HAS_GENERIC_MODEL = True
+except ImportError:
+    HAS_GENERIC_MODEL = False
+
+
+class _PlaceholderModel:
+    def __init__(self, *args, **kwargs):
+        if not HAS_STATSMODELS:
+            raise ImportError("需要安装statsmodels库: pip install statsmodels")
+    
+    def fit(self, *args, **kwargs):
+        pass
+
+
+class TobitModel:
+    """
+    Tobit模型（截断回归模型）
+    由于statsmodels中没有内置的Tobit模型，这里提供一个基于GenericLikelihoodModel的实现
+    """
+    
+    def __init__(self, lower_bound=0, upper_bound=None):
+        """
+        初始化Tobit模型
+        
+        参数:
+        lower_bound: 下界阈值，默认为0
+        upper_bound: 上界阈值，默认为None（无上界）
+        """
+        if not HAS_STATSMODELS:
+            raise ImportError("需要安装statsmodels库: pip install statsmodels")
+            
+        if not HAS_GENERIC_MODEL:
+            raise ImportError("需要statsmodels的GenericLikelihoodModel支持")
+            
+        self.lower_bound = lower_bound
+        self.upper_bound = upper_bound
+        self.model_ = None
+        self.results_ = None
+        self.fitted_ = False
+        
+    def fit(self, X, y):
+        """拟合Tobit模型"""
+        X = np.array(X)
+        y = np.array(y)
+        
+        # 添加常数项
+        X_with_const = sm.add_constant(X)
+        
+        # 定义Tobit似然函数
+        class TobitLikelihoodModel(GenericLikelihoodModel):
+            def __init__(self, endog, exog, lower_bound=0, upper_bound=None, **kwds):
+                self.lower_bound = lower_bound
+                self.upper_bound = upper_bound
+                super(TobitLikelihoodModel, self).__init__(endog, exog, **kwds)
+            
+            def loglikeobs(self, params):
+                # 分离系数和sigma
+                beta = params[:-1]
+                sigma = params[-1]
+                
+                if sigma <= 0:
+                    return np.full_like(self.endog, -np.inf)
+                
+                # 预测值
+                xb = np.dot(self.exog, beta)
+                z = (self.endog - xb) / sigma
+                
+                # 计算对数似然
+                if self.upper_bound is None:
+                    # 只有下界的情况
+                    censored = self.endog <= self.lower_bound
+                    uncensored = ~censored
+                    
+                    ll = np.zeros_like(self.endog)
+                    # 截断观测的对数似然
+                    ll[censored] = stats.norm.logcdf((self.lower_bound - xb[censored]) / sigma)
+                    # 未截断观测的对数似然
+                    ll[uncensored] = -0.5 * np.log(2 * np.pi * sigma**2) - 0.5 * z[uncensored]**2
+                else:
+                    # 双边截断的情况
+                    left_censored = self.endog <= self.lower_bound
+                    right_censored = self.endog >= self.upper_bound
+                    uncensored = ~(left_censored | right_censored)
+                    
+                    ll = np.zeros_like(self.endog)
+                    # 左截断观测的对数似然
+                    ll[left_censored] = stats.norm.logcdf((self.lower_bound - xb[left_censored]) / sigma)
+                    # 右截断观测的对数似然
+                    ll[right_censored] = stats.norm.logsf((self.upper_bound - xb[right_censored]) / sigma)
+                    # 未截断观测的对数似然
+                    ll[uncensored] = -0.5 * np.log(2 * np.pi * sigma**2) - 0.5 * z[uncensored]**2
+                
+                return ll
+        
+        # 创建并拟合模型
+        self.model_ = TobitLikelihoodModel(
+            endog=y, 
+            exog=X_with_const, 
+            lower_bound=self.lower_bound, 
+            upper_bound=self.upper_bound
+        )
+        
+        # 初始化参数
+        n_features = X_with_const.shape[1]
+        initial_params = np.concatenate([
+            np.zeros(n_features),  # beta
+            [np.std(y[y > self.lower_bound]) if self.upper_bound is None else np.std(y)]  # sigma
+        ])
+        
+        self.results_ = self.model_.fit(start_params=initial_params, method='bfgs', disp=0)
+        self.fitted_ = True
+        return self
+    
+    def predict(self, X):
+        """预测期望值"""
+        if not self.fitted_:
+            raise ValueError("模型尚未拟合")
+        X = np.array(X)
+        X_with_const = sm.add_constant(X)
+        
+        # 手动计算预测值
+        beta = self.results_.params[:-1]  # 排除sigma参数
+        sigma = self.results_.params[-1]
+        
+        xb = np.dot(X_with_const, beta)
+        
+        if self.upper_bound is None:
+            # 只有下界的情况
+            z = (self.lower_bound - xb) / sigma
+            lambda_val = stats.norm.pdf(z) / np.clip(1 - stats.norm.cdf(z), 1e-10, 1)
+            return xb + sigma * lambda_val
+        else:
+            # 双边截断的情况
+            z_lower = (self.lower_bound - xb) / sigma
+            z_upper = (self.upper_bound - xb) / sigma
+            
+            lambda_lower = stats.norm.pdf(z_lower) / np.clip(stats.norm.cdf(z_upper) - stats.norm.cdf(z_lower), 1e-10, 1)
+            lambda_upper = stats.norm.pdf(z_upper) / np.clip(stats.norm.cdf(z_upper) - stats.norm.cdf(z_lower), 1e-10, 1)
+            
+            return xb + sigma * (lambda_lower - lambda_upper)
+    
+    def predict_linear(self, X):
+        """预测线性预测值"""
+        if not self.fitted_:
+            raise ValueError("模型尚未拟合")
+        X = np.array(X)
+        X_with_const = sm.add_constant(X)
+        xb = np.dot(X_with_const, self.results_.params[:-1])  # 排除sigma参数
+        return xb
+    
+    def summary(self):
+        """返回模型摘要"""
+        if not self.fitted_:
+            raise ValueError("模型尚未拟合")
+        return self.results_.summary()
+
+
+class HeckmanModel:
+    """
+    Heckman两阶段选择模型 (基于statsmodels实现)
+    """
+    
+    def __init__(self):
+        self.selection_model_ = None
+        self.selection_results_ = None
+        self.outcome_model_ = None
+        self.outcome_results_ = None
+        self.fitted_ = False
+        
+    def fit(self, X_select, Z, y, s):
+        """
+        拟合Heckman模型
+        
+        参数:
+        X_select: 选择方程的解释变量矩阵
+        Z: 结果方程的解释变量矩阵
+        y: 结果变量向量（仅对选择样本可观测）
+        s: 选择指示变量向量（1表示被选择，0表示未被选择）
+        """
+        if not HAS_STATSMODELS:
+            raise ImportError("需要安装statsmodels库: pip install statsmodels")
+            
+        X_select = np.array(X_select)
+        Z = np.array(Z)
+        y = np.array(y)
+        s = np.array(s)
+        
+        # 第一阶段：Probit模型估计选择方程
+        X_select_with_const = sm.add_constant(X_select)
+        self.selection_model_ = sm.Probit(s, X_select_with_const)
+        self.selection_results_ = self.selection_model_.fit(disp=0)
+        
+        # 计算逆米尔斯比率 (Inverse Mills Ratio)
+        X_select_linpred = np.dot(X_select_with_const, self.selection_results_.params)
+        mills_ratio = stats.norm.pdf(X_select_linpred) / np.clip(stats.norm.cdf(X_select_linpred), 1e-10, 1-1e-10)
+        # 对于未被选择的样本，米尔斯比率为0
+        mills_ratio = mills_ratio * s
+        
+        # 第二阶段：加入逆米尔斯比率的结果方程OLS
+        Z_with_mills = np.column_stack([Z, mills_ratio])
+        Z_with_mills_const = sm.add_constant(Z_with_mills)
+        
+        # 只对被选择的样本进行回归
+        selected_mask = s == 1
+        Z_selected = Z_with_mills_const[selected_mask]
+        y_selected = y[selected_mask]
+        
+        self.outcome_model_ = OLS(y_selected, Z_selected)
+        self.outcome_results_ = self.outcome_model_.fit()
+        
+        self.fitted_ = True
+        return self
+    
+    def predict(self, X_select, Z):
+        """预测结果值"""
+        if not self.fitted_:
+            raise ValueError("模型尚未拟合")
+            
+        X_select = np.array(X_select)
+        Z = np.array(Z)
+        
+        # 添加常数项
+        X_select_with_const = sm.add_constant(X_select)
+        
+        # 计算逆米尔斯比率
+        X_select_linpred = np.dot(X_select_with_const, self.selection_results_.params)
+        mills_ratio = stats.norm.pdf(X_select_linpred) / np.clip(stats.norm.cdf(X_select_linpred), 1e-10, 1-1e-10)
+        
+        # 构建预测矩阵：Z + 逆米尔斯比率 + 常数项
+        Z_with_mills = np.column_stack([Z, mills_ratio])
+        Z_with_mills_const = sm.add_constant(Z_with_mills)
+        
+        # 计算结果方程预测值
+        outcome_pred = self.outcome_results_.predict(Z_with_mills_const)
+        
+        return outcome_pred
+    
+    def summary(self):
+        """返回模型摘要"""
+        if not self.fitted_:
+            raise ValueError("模型尚未拟合")
+        return {
+            'selection_summary': self.selection_results_.summary(),
+            'outcome_summary': self.outcome_results_.summary()
+        }
+
+
+# 如果statsmodels不可用，则使用占位符
+if not HAS_STATSMODELS:
+    TobitModel = _PlaceholderModel
+    HeckmanModel = _PlaceholderModel
+
+def multinomial_logit():
+    """
+    多项Logit模型占位符
+    """
+    pass
+
+
+def nested_logit():
+    """
+    嵌套Logit模型占位符
+    """
+    pass

econometrics/statistical_inference/__init__.py

@@ -0,0 +1,21 @@
+"""
+统计推断技术模块
+提供重采样、模拟和渐近推断方法
+"""
+
+from .bootstrap_methods import (
+    bootstrap_inference,
+    BootstrapResult
+)
+
+from .permutation_test import (
+    permutation_test,
+    PermutationTestResult
+)
+
+__all__ = [
+    'bootstrap_inference',
+    'BootstrapResult',
+    'permutation_test',
+    'PermutationTestResult'
+]

econometrics/statistical_inference/bootstrap_methods.py

@@ -0,0 +1,162 @@
+"""
+Bootstrap重采样推断方法
+基于 scipy.stats 实现多种Bootstrap方法
+"""
+
+from typing import List, Optional, Callable, Tuple, Dict
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from scipy import stats
+    SCIPY_AVAILABLE = True
+except ImportError:
+    SCIPY_AVAILABLE = False
+    stats = None
+
+
+class BootstrapResult(BaseModel):
+    """Bootstrap推断结果"""
+    statistic: float = Field(..., description="统计量估计值")
+    bootstrap_mean: float = Field(..., description="Bootstrap均值")
+    bootstrap_std: float = Field(..., description="Bootstrap标准误")
+    confidence_interval: Tuple[float, float] = Field(..., description="置信区间")
+    bias: float = Field(..., description="偏差估计")
+    confidence_level: float = Field(..., description="置信水平")
+    n_bootstrap: int = Field(..., description="Bootstrap重采样次数")
+    method: str = Field(..., description="Bootstrap方法")
+    bootstrap_distribution: List[float] = Field(..., description="Bootstrap统计量分布（前100个）")
+    summary: str = Field(..., description="摘要信息")
+
+
+def bootstrap_inference(
+    data: List[float],
+    statistic_func: Optional[str] = "mean",
+    n_bootstrap: int = 1000,
+    confidence_level: float = 0.95,
+    method: str = "percentile",
+    random_state: Optional[int] = None
+) -> BootstrapResult:
+    """
+    Bootstrap置信区间估计
+    
+    Args:
+        data: 样本数据
+        statistic_func: 统计量函数 - "mean"(均值), "median"(中位数), 
+                        "std"(标准差), "var"(方差)
+        n_bootstrap: Bootstrap重采样次数
+        confidence_level: 置信水平
+        method: 置信区间方法 - "percentile"(百分位法), "bca"(BCa法)
+        random_state: 随机种子
+        
+    Returns:
+        BootstrapResult: Bootstrap推断结果
+        
+    Raises:
+        ImportError: scipy库未安装
+        ValueError: 输入数据无效
+    """
+    if not SCIPY_AVAILABLE:
+        raise ImportError("scipy库未安装。请运行: pip install scipy")
+    
+    # 输入验证
+    if not data:
+        raise ValueError("data不能为空")
+    
+    # 数据准备
+    data_arr = np.array(data, dtype=np.float64)
+    n = len(data_arr)
+    
+    # 设置随机种子
+    if random_state is not None:
+        np.random.seed(random_state)
+    
+    # 定义统计量函数
+    if statistic_func == "mean":
+        stat_fn = np.mean
+    elif statistic_func == "median":
+        stat_fn = np.median
+    elif statistic_func == "std":
+        stat_fn = lambda x: np.std(x, ddof=1)
+    elif statistic_func == "var":
+        stat_fn = lambda x: np.var(x, ddof=1)
+    elif callable(statistic_func):
+        stat_fn = statistic_func
+    else:
+        raise ValueError(f"不支持的统计量: {statistic_func}")
+    
+    # 计算原始统计量
+    original_stat = float(stat_fn(data_arr))
+    
+    # 执行Bootstrap重采样
+    bootstrap_stats = []
+    for _ in range(n_bootstrap):
+        # 有放回抽样
+        bootstrap_sample = np.random.choice(data_arr, size=n, replace=True)
+        bootstrap_stat = stat_fn(bootstrap_sample)
+        bootstrap_stats.append(bootstrap_stat)
+    
+    bootstrap_stats = np.array(bootstrap_stats)
+    
+    # 计算Bootstrap统计量
+    bootstrap_mean = float(bootstrap_stats.mean())
+    bootstrap_std = float(bootstrap_stats.std(ddof=1))
+    bias = bootstrap_mean - original_stat
+    
+    # 计算置信区间
+    alpha = 1 - confidence_level
+    
+    if method == "percentile":
+        # 百分位法
+        lower_percentile = alpha / 2 * 100
+        upper_percentile = (1 - alpha / 2) * 100
+        ci_lower = float(np.percentile(bootstrap_stats, lower_percentile))
+        ci_upper = float(np.percentile(bootstrap_stats, upper_percentile))
+    elif method == "normal":
+        # 正态近似法
+        z_score = stats.norm.ppf(1 - alpha / 2)
+        ci_lower = original_stat - z_score * bootstrap_std
+        ci_upper = original_stat + z_score * bootstrap_std
+    elif method == "basic":
+        # 基本Bootstrap法
+        lower_percentile = alpha / 2 * 100
+        upper_percentile = (1 - alpha / 2) * 100
+        ci_lower = 2 * original_stat - float(np.percentile(bootstrap_stats, upper_percentile))
+        ci_upper = 2 * original_stat - float(np.percentile(bootstrap_stats, lower_percentile))
+    else:
+        raise ValueError(f"不支持的置信区间方法: {method}")
+    
+    # 保存前100个Bootstrap统计量（用于展示）
+    bootstrap_dist_sample = bootstrap_stats[:min(100, len(bootstrap_stats))].tolist()
+    
+    # 生成摘要
+    summary = f"""Bootstrap推断:
+- 样本量: {n}
+- Bootstrap次数: {n_bootstrap}
+- 统计量: {statistic_func}
+- 置信区间方法: {method}
+
+估计结果:
+- 统计量估计: {original_stat:.4f}
+- Bootstrap均值: {bootstrap_mean:.4f}
+- Bootstrap标准误: {bootstrap_std:.4f}
+- 偏差: {bias:.4f}
+
+{int(confidence_level*100)}% 置信区间:
+- 下界: {ci_lower:.4f}
+- 上界: {ci_upper:.4f}
+- 区间宽度: {ci_upper - ci_lower:.4f}
+"""
+    
+    return BootstrapResult(
+        statistic=original_stat,
+        bootstrap_mean=bootstrap_mean,
+        bootstrap_std=bootstrap_std,
+        confidence_interval=(ci_lower, ci_upper),
+        bias=bias,
+        confidence_level=confidence_level,
+        n_bootstrap=n_bootstrap,
+        method=method,
+        bootstrap_distribution=bootstrap_dist_sample,
+        summary=summary
+    )

econometrics/statistical_inference/permutation_test.py

@@ -0,0 +1,177 @@
+"""
+置换检验 (Permutation Test)
+非参数假设检验方法
+基于 scipy.stats 实现
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from scipy import stats
+    SCIPY_AVAILABLE = True
+except ImportError:
+    SCIPY_AVAILABLE = False
+    stats = None
+
+
+class PermutationTestResult(BaseModel):
+    """置换检验结果"""
+    statistic: float = Field(..., description="观测统计量")
+    p_value: float = Field(..., description="P值")
+    null_distribution_mean: float = Field(..., description="零假设分布均值")
+    null_distribution_std: float = Field(..., description="零假设分布标准差")
+    n_permutations: int = Field(..., description="置换次数")
+    alternative: str = Field(..., description="备择假设")
+    test_type: str = Field(..., description="检验类型")
+    n_sample_a: int = Field(..., description="样本A大小")
+    n_sample_b: int = Field(..., description="样本B大小")
+    permutation_distribution: List[float] = Field(..., description="置换分布（前100个）")
+    summary: str = Field(..., description="摘要信息")
+
+
+def permutation_test(
+    sample_a: List[float],
+    sample_b: List[float],
+    test_type: str = "mean_difference",
+    alternative: str = "two-sided",
+    n_permutations: int = 10000,
+    random_state: Optional[int] = None
+) -> PermutationTestResult:
+    """
+    置换检验（两样本）
+    
+    Args:
+        sample_a: 样本A
+        sample_b: 样本B
+        test_type: 检验类型 - "mean_difference"(均值差异), 
+                   "median_difference"(中位数差异),
+                   "variance_ratio"(方差比)
+        alternative: 备择假设 - "two-sided", "less", "greater"
+        n_permutations: 置换次数
+        random_state: 随机种子
+        
+    Returns:
+        PermutationTestResult: 置换检验结果
+        
+    Raises:
+        ImportError: scipy库未安装
+        ValueError: 输入数据无效
+    """
+    if not SCIPY_AVAILABLE:
+        raise ImportError("scipy库未安装。请运行: pip install scipy")
+    
+    # 输入验证
+    if not sample_a or not sample_b:
+        raise ValueError("两个样本都不能为空")
+    
+    # 数据准备
+    a = np.array(sample_a, dtype=np.float64)
+    b = np.array(sample_b, dtype=np.float64)
+    
+    n_a = len(a)
+    n_b = len(b)
+    
+    # 设置随机种子
+    if random_state is not None:
+        np.random.seed(random_state)
+    
+    # 合并数据
+    combined = np.concatenate([a, b])
+    n_total = len(combined)
+    
+    # 定义统计量函数
+    if test_type == "mean_difference":
+        def stat_func(x, y):
+            return np.mean(x) - np.mean(y)
+    elif test_type == "median_difference":
+        def stat_func(x, y):
+            return np.median(x) - np.median(y)
+    elif test_type == "variance_ratio":
+        def stat_func(x, y):
+            return np.var(x, ddof=1) / np.var(y, ddof=1) if np.var(y, ddof=1) > 0 else 0
+    else:
+        raise ValueError(f"不支持的检验类型: {test_type}")
+    
+    # 计算观测统计量
+    observed_stat = stat_func(a, b)
+    
+    # 执行置换检验
+    perm_stats = []
+    for _ in range(n_permutations):
+        # 随机置换
+        perm = np.random.permutation(combined)
+        perm_a = perm[:n_a]
+        perm_b = perm[n_a:]
+        perm_stat = stat_func(perm_a, perm_b)
+        perm_stats.append(perm_stat)
+    
+    perm_stats = np.array(perm_stats)
+    
+    # 计算p值
+    if alternative == "two-sided":
+        p_value = np.mean(np.abs(perm_stats) >= np.abs(observed_stat))
+    elif alternative == "greater":
+        p_value = np.mean(perm_stats >= observed_stat)
+    elif alternative == "less":
+        p_value = np.mean(perm_stats <= observed_stat)
+    else:
+        raise ValueError(f"不支持的备择假设: {alternative}")
+    
+    # 零假设分布的统计特征
+    null_mean = float(perm_stats.mean())
+    null_std = float(perm_stats.std(ddof=1))
+    
+    # 保存前100个置换统计量
+    perm_dist_sample = perm_stats[:min(100, len(perm_stats))].tolist()
+    
+    # 判断显著性
+    if p_value < 0.01:
+        significance = "高度显著"
+    elif p_value < 0.05:
+        significance = "显著"
+    elif p_value < 0.10:
+        significance = "边际显著"
+    else:
+        significance = "不显著"
+    
+    # 生成摘要
+    test_names = {
+        "mean_difference": "均值差异",
+        "median_difference": "中位数差异",
+        "variance_ratio": "方差比"
+    }
+    
+    summary = f"""置换检验:
+- 检验类型: {test_names.get(test_type, test_type)}
+- 备择假设: {alternative}
+- 置换次数: {n_permutations}
+
+样本信息:
+- 样本A: n={n_a}, 均值={a.mean():.4f}
+- 样本B: n={n_b}, 均值={b.mean():.4f}
+
+检验结果:
+- 观测统计量: {observed_stat:.4f}
+- P值: {p_value:.4f}
+- 显著性: {significance}
+
+零假设分布:
+- 均值: {null_mean:.4f}
+- 标准差: {null_std:.4f}
+"""
+    
+    return PermutationTestResult(
+        statistic=float(observed_stat),
+        p_value=float(p_value),
+        null_distribution_mean=null_mean,
+        null_distribution_std=null_std,
+        n_permutations=n_permutations,
+        alternative=alternative,
+        test_type=test_type,
+        n_sample_a=n_a,
+        n_sample_b=n_b,
+        permutation_distribution=perm_dist_sample,
+        summary=summary
+    )

econometrics/survival_analysis/__init__.py

@@ -0,0 +1,18 @@
+"""
+生存分析模块
+分析事件发生时间数据
+"""
+
+from .survival_models import (
+    kaplan_meier_estimation_simple,
+    cox_regression_simple,
+    KaplanMeierResult,
+    CoxRegressionResult
+)
+
+__all__ = [
+    'kaplan_meier_estimation_simple',
+    'cox_regression_simple',
+    'KaplanMeierResult',
+    'CoxRegressionResult'
+]