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

econometrics/nonparametric/kernel_regression.py

@@ -0,0 +1,161 @@
+"""
+核回归 (Kernel Regression)
+基于 statsmodels.nonparametric 库实现
+"""
+
+from typing import List, Optional, Tuple
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from statsmodels.nonparametric.kernel_regression import KernelReg
+    STATSMODELS_AVAILABLE = True
+except ImportError:
+    STATSMODELS_AVAILABLE = False
+    KernelReg = None
+
+
+class KernelRegressionResult(BaseModel):
+    """核回归结果"""
+    fitted_values: List[float] = Field(..., description="拟合值")
+    residuals: List[float] = Field(..., description="残差")
+    bandwidth: List[float] = Field(..., description="带宽参数")
+    kernel_type: str = Field(..., description="核函数类型")
+    n_observations: int = Field(..., description="观测数量")
+    n_predictors: int = Field(..., description="预测变量数量")
+    r_squared: float = Field(..., description="R²统计量")
+    aic: Optional[float] = Field(None, description="AIC信息准则")
+    summary: str = Field(..., description="摘要信息")
+
+
+def kernel_regression(
+    y_data: List[float],
+    x_data: List[List[float]],
+    kernel_type: str = "gaussian",
+    bandwidth: Optional[List[float]] = None,
+    bandwidth_method: str = "cv_ls",
+    variable_type: Optional[str] = None
+) -> KernelRegressionResult:
+    """
+    核回归估计
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（二维列表）
+        kernel_type: 核函数类型 - "gaussian"(高斯), "epanechnikov"(Epanechnikov核),
+                     "uniform"(均匀核), "triangular"(三角核), "biweight"(双权核)
+        bandwidth: 带宽参数（每个变量一个），如果为None则自动选择
+        bandwidth_method: 带宽选择方法 - "cv_ls"(交叉验证最小二乘),
+                          "aic"(AIC准则), "normal_reference"(正态参考)
+        variable_type: 变量类型 - None(全部连续), "c"(连续), "u"(无序分类), "o"(有序分类)
+                       可以是字符串（如 "cco"表示3个变量：连续、连续、有序）
+        
+    Returns:
+        KernelRegressionResult: 核回归结果
+        
+    Raises:
+        ImportError: statsmodels库未安装
+        ValueError: 输入数据无效
+    """
+    if not STATSMODELS_AVAILABLE:
+        raise ImportError(
+            "statsmodels库未安装。请运行: pip install statsmodels"
+        )
+    
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("y_data和x_data不能为空")
+    
+    # 数据准备
+    y = np.array(y_data, dtype=np.float64)
+    X = np.array(x_data, dtype=np.float64)
+    
+    # 确保X是二维数组
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n = len(y)
+    k = X.shape[1]
+    
+    # 数据验证
+    if len(y) != X.shape[0]:
+        raise ValueError(f"因变量长度({len(y)})与自变量长度({X.shape[0]})不一致")
+    
+    # 变量类型设置
+    if variable_type is None:
+        var_type = 'c' * k  # 默认全部为连续变量
+    else:
+        var_type = variable_type
+        if len(var_type) != k:
+            raise ValueError(f"variable_type长度({len(var_type)})与自变量数量({k})不一致")
+    
+    # 构建核回归模型
+    try:
+        if bandwidth is None:
+            # 自动选择带宽
+            kr = KernelReg(
+                endog=y,
+                exog=X,
+                var_type=var_type,
+                reg_type='ll',  # 局部线性回归
+                bw=bandwidth_method
+            )
+        else:
+            # 使用指定带宽
+            if len(bandwidth) != k:
+                raise ValueError(f"bandwidth长度({len(bandwidth)})与自变量数量({k})不一致")
+            kr = KernelReg(
+                endog=y,
+                exog=X,
+                var_type=var_type,
+                reg_type='ll',
+                bw=np.array(bandwidth)
+            )
+    except Exception as e:
+        raise ValueError(f"核回归模型构建失败: {str(e)}")
+    
+    # 拟合值
+    fitted_values, _ = kr.fit(X)
+    fitted_values = fitted_values.flatten()
+    
+    # 残差
+    residuals = y - fitted_values
+    
+    # 带宽
+    bw = kr.bw.tolist() if hasattr(kr.bw, 'tolist') else [float(kr.bw)]
+    
+    # R²
+    ss_res = np.sum(residuals ** 2)
+    ss_tot = np.sum((y - np.mean(y)) ** 2)
+    r_squared = float(1 - ss_res / ss_tot) if ss_tot > 0 else 0.0
+    
+    # AIC（近似计算）
+    try:
+        log_likelihood = -0.5 * n * (np.log(2 * np.pi) + np.log(ss_res / n) + 1)
+        aic = float(2 * k - 2 * log_likelihood)
+    except:
+        aic = None
+    
+    # 生成摘要
+    summary = f"""核回归分析:
+- 观测数量: {n}
+- 预测变量: {k}
+- 核函数: {kernel_type}
+- 带宽: {[f'{b:.4f}' for b in bw]}
+- 带宽方法: {bandwidth_method}
+- R²: {r_squared:.4f}
+"""
+    if aic is not None:
+        summary += f"- AIC: {aic:.2f}\n"
+    
+    return KernelRegressionResult(
+        fitted_values=fitted_values.tolist(),
+        residuals=residuals.tolist(),
+        bandwidth=bw,
+        kernel_type=kernel_type,
+        n_observations=n,
+        n_predictors=k,
+        r_squared=r_squared,
+        aic=aic,
+        summary=summary
+    )

econometrics/nonparametric/quantile_regression.py

@@ -0,0 +1,249 @@
+"""
+分位数回归 (Quantile Regression)
+基于 statsmodels.regression.quantile_regression 库实现
+"""
+
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    import statsmodels.api as sm
+    from statsmodels.regression.quantile_regression import QuantReg
+    STATSMODELS_AVAILABLE = True
+except ImportError:
+    STATSMODELS_AVAILABLE = False
+    QuantReg = None
+
+
+class QuantileRegressionResult(BaseModel):
+    """分位数回归结果"""
+    quantile: float = Field(..., description="分位数水平")
+    coefficients: List[float] = Field(..., description="回归系数")
+    std_errors: List[float] = Field(..., description="标准误")
+    t_values: List[float] = Field(..., description="t统计量")
+    p_values: List[float] = Field(..., description="p值")
+    conf_int_lower: List[float] = Field(..., description="置信区间下界")
+    conf_int_upper: List[float] = Field(..., description="置信区间上界")
+    feature_names: List[str] = Field(..., description="特征名称")
+    pseudo_r_squared: float = Field(..., description="伪R²")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+class MultiQuantileResult(BaseModel):
+    """多分位数回归结果"""
+    quantiles: List[float] = Field(..., description="分位数水平列表")
+    coefficients_by_quantile: Dict[str, List[float]] = Field(..., description="各分位数的系数")
+    feature_names: List[str] = Field(..., description="特征名称")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def quantile_regression(
+    y_data: List[float],
+    x_data: List[List[float]],
+    quantile: float = 0.5,
+    feature_names: Optional[List[str]] = None,
+    confidence_level: float = 0.95
+) -> QuantileRegressionResult:
+    """
+    分位数回归
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（二维列表）
+        quantile: 分位数水平（0-1之间），默认0.5为中位数回归
+        feature_names: 特征名称
+        confidence_level: 置信水平
+        
+    Returns:
+        QuantileRegressionResult: 分位数回归结果
+        
+    Raises:
+        ImportError: statsmodels库未安装
+        ValueError: 输入数据无效
+    """
+    if not STATSMODELS_AVAILABLE:
+        raise ImportError(
+            "statsmodels库未安装。请运行: pip install statsmodels"
+        )
+    
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("y_data和x_data不能为空")
+    
+    if not 0 < quantile < 1:
+        raise ValueError("quantile必须在0和1之间")
+    
+    # 数据准备
+    y = np.array(y_data, dtype=np.float64)
+    X = np.array(x_data, dtype=np.float64)
+    
+    # 确保X是二维数组
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n = len(y)
+    k = X.shape[1]
+    
+    # 数据验证
+    if len(y) != X.shape[0]:
+        raise ValueError(f"因变量长度({len(y)})与自变量长度({X.shape[0]})不一致")
+    
+    # 添加常数项
+    X_with_const = sm.add_constant(X)
+    
+    # 特征名称
+    if feature_names is None:
+        feature_names = [f"X{i+1}" for i in range(k)]
+    all_feature_names = ["const"] + feature_names
+    
+    # 构建并拟合分位数回归模型
+    try:
+        model = QuantReg(y, X_with_const)
+        results = model.fit(q=quantile)
+    except Exception as e:
+        raise ValueError(f"分位数回归拟合失败: {str(e)}")
+    
+    # 提取结果
+    coefficients = results.params.tolist()
+    
+    # 标准误（使用稳健标准误）
+    try:
+        # 尝试使用稳健标准误
+        std_errors = results.bse.tolist()
+    except:
+        # 如果失败，使用常规标准误
+        std_errors = [0.0] * len(coefficients)
+    
+    # t统计量和p值
+    try:
+        t_values = results.tvalues.tolist()
+        p_values = results.pvalues.tolist()
+    except:
+        t_values = [0.0] * len(coefficients)
+        p_values = [1.0] * len(coefficients)
+    
+    # 置信区间
+    try:
+        alpha = 1 - confidence_level
+        conf_int = results.conf_int(alpha=alpha)
+        conf_int_lower = conf_int.iloc[:, 0].tolist()
+        conf_int_upper = conf_int.iloc[:, 1].tolist()
+    except:
+        conf_int_lower = [c - 1.96 * se for c, se in zip(coefficients, std_errors)]
+        conf_int_upper = [c + 1.96 * se for c, se in zip(coefficients, std_errors)]
+    
+    # 伪R²
+    try:
+        pseudo_r_squared = float(results.prsquared)
+    except:
+        pseudo_r_squared = 0.0
+    
+    # 生成摘要
+    summary = f"""分位数回归分析:
+- 分位数τ: {quantile}
+- 观测数量: {n}
+- 协变量数: {k}
+- 伪R²: {pseudo_r_squared:.4f}
+
+系数估计:
+"""
+    for i, (name, coef, se, t, p) in enumerate(zip(
+        all_feature_names, coefficients, std_errors, t_values, p_values
+    )):
+        sig = "***" if p < 0.01 else "**" if p < 0.05 else "*" if p < 0.10 else ""
+        summary += f"  {name}: {coef:.4f} (SE: {se:.4f}, t={t:.2f}, p={p:.4f}){sig}\n"
+    
+    return QuantileRegressionResult(
+        quantile=quantile,
+        coefficients=coefficients,
+        std_errors=std_errors,
+        t_values=t_values,
+        p_values=p_values,
+        conf_int_lower=conf_int_lower,
+        conf_int_upper=conf_int_upper,
+        feature_names=all_feature_names,
+        pseudo_r_squared=pseudo_r_squared,
+        n_observations=n,
+        summary=summary
+    )
+
+
+def multi_quantile_regression(
+    y_data: List[float],
+    x_data: List[List[float]],
+    quantiles: List[float] = [0.1, 0.25, 0.5, 0.75, 0.9],
+    feature_names: Optional[List[str]] = None
+) -> MultiQuantileResult:
+    """
+    多分位数回归
+    同时估计多个分位数水平的回归系数
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量
+        quantiles: 分位数水平列表
+        feature_names: 特征名称
+        
+    Returns:
+        MultiQuantileResult: 多分位数回归结果
+    """
+    if not STATSMODELS_AVAILABLE:
+        raise ImportError("statsmodels库未安装")
+    
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("y_data和x_data不能为空")
+    
+    # 数据准备
+    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 = len(y)
+    k = X.shape[1]
+    
+    # 添加常数项
+    X_with_const = sm.add_constant(X)
+    
+    # 特征名称
+    if feature_names is None:
+        feature_names = [f"X{i+1}" for i in range(k)]
+    all_feature_names = ["const"] + feature_names
+    
+    # 对每个分位数进行回归
+    coefficients_by_quantile = {}
+    
+    for q in quantiles:
+        try:
+            model = QuantReg(y, X_with_const)
+            results = model.fit(q=q)
+            coefficients_by_quantile[f"τ={q}"] = results.params.tolist()
+        except Exception as e:
+            coefficients_by_quantile[f"τ={q}"] = [np.nan] * (k + 1)
+    
+    # 生成摘要
+    summary = f"""多分位数回归分析:
+- 观测数量: {n}
+- 协变量数: {k}
+- 分位数: {quantiles}
+
+各分位数的系数估计:
+"""
+    for name_idx, name in enumerate(all_feature_names):
+        summary += f"\n{name}:\n"
+        for q in quantiles:
+            coef = coefficients_by_quantile[f"τ={q}"][name_idx]
+            summary += f"  τ={q}: {coef:.4f}\n"
+    
+    return MultiQuantileResult(
+        quantiles=quantiles,
+        coefficients_by_quantile=coefficients_by_quantile,
+        feature_names=all_feature_names,
+        n_observations=n,
+        summary=summary
+    )

econometrics/nonparametric/spline_regression.py

@@ -0,0 +1,100 @@
+"""
+样条回归
+基于 sklearn 和 scipy 实现
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from sklearn.preprocessing import SplineTransformer
+    from sklearn.linear_model import LinearRegression
+    from sklearn.pipeline import Pipeline
+    SKLEARN_AVAILABLE = True
+except ImportError:
+    SKLEARN_AVAILABLE = False
+    SplineTransformer = None
+
+
+class SplineRegressionResult(BaseModel):
+    """样条回归结果"""
+    fitted_values: List[float] = Field(..., description="拟合值")
+    residuals: List[float] = Field(..., description="残差")
+    coefficients: List[float] = Field(..., description="样条基函数系数")
+    n_knots: int = Field(..., description="节点数")
+    degree: int = Field(..., description="样条次数")
+    r_squared: float = Field(..., description="R²")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def spline_regression(
+    y_data: List[float],
+    x_data: List[float],
+    n_knots: int = 5,
+    degree: int = 3,
+    knots: str = "uniform"
+) -> SplineRegressionResult:
+    """
+    样条回归
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（单变量）
+        n_knots: 节点数量
+        degree: 样条次数（通常3表示三次样条）
+        knots: 节点分布 - "uniform"(均匀), "quantile"(分位数)
+        
+    Returns:
+        SplineRegressionResult: 样条回归结果
+    """
+    if not SKLEARN_AVAILABLE:
+        raise ImportError("sklearn库未安装。请运行: pip install scikit-learn")
+    
+    # 数据准备
+    y = np.array(y_data, dtype=np.float64)
+    X = np.array(x_data, dtype=np.float64).reshape(-1, 1)
+    
+    n = len(y)
+    
+    # 创建样条转换器+线性回归管道
+    pipeline = Pipeline([
+        ('spline', SplineTransformer(n_knots=n_knots, degree=degree, knots=knots)),
+        ('linear', LinearRegression())
+    ])
+    
+    # 拟合模型
+    pipeline.fit(X, y)
+    
+    # 预测
+    y_pred = pipeline.predict(X)
+    
+    # 残差和R²
+    residuals = y - y_pred
+    ss_res = np.sum(residuals ** 2)
+    ss_tot = np.sum((y - y.mean()) ** 2)
+    r_squared = float(1 - ss_res / ss_tot) if ss_tot > 0 else 0.0
+    
+    # 系数
+    coefficients = pipeline.named_steps['linear'].coef_.tolist()
+    
+    summary = f"""样条回归:
+- 观测数量: {n}
+- 节点数: {n_knots}
+- 样条次数: {degree}
+- 节点分布: {knots}
+- R²: {r_squared:.4f}
+- 样条基函数数量: {len(coefficients)}
+"""
+    
+    return SplineRegressionResult(
+        fitted_values=y_pred.tolist(),
+        residuals=residuals.tolist(),
+        coefficients=coefficients,
+        n_knots=n_knots,
+        degree=degree,
+        r_squared=r_squared,
+        n_observations=n,
+        summary=summary
+    )

econometrics/spatial_econometrics/__init__.py

@@ -0,0 +1,68 @@
+"""
+空间计量经济学模块
+处理空间依赖性和空间异质性
+
+主要功能：
+1. 空间权重矩阵构建
+2. 空间自相关检验（Moran's I, Geary's C, Local LISA）
+3. 空间回归模型（SAR, SEM, SDM）
+4. 地理加权回归（GWR）
+"""
+
+# 空间权重矩阵
+from .spatial_weights import (
+    create_spatial_weights,
+    SpatialWeightsResult
+)
+
+# 空间自相关检验
+from .spatial_autocorrelation import (
+    morans_i_test,
+    gearys_c_test,
+    local_morans_i,
+    MoranIResult,
+    GearysCResult,
+    LocalMoranResult
+)
+
+# 空间回归模型
+from .spatial_regression import (
+    spatial_lag_model,
+    spatial_error_model,
+    SpatialRegressionResult
+)
+
+# 空间杜宾模型
+from .spatial_durbin_model import (
+    spatial_durbin_model,
+    SpatialDurbinResult
+)
+
+# 地理加权回归
+from .geographically_weighted_regression import (
+    geographically_weighted_regression,
+    GWRResult
+)
+
+__all__ = [
+    # 空间权重
+    'create_spatial_weights',
+    'SpatialWeightsResult',
+    # 空间自相关
+    'morans_i_test',
+    'gearys_c_test',
+    'local_morans_i',
+    'MoranIResult',
+    'GearysCResult',
+    'LocalMoranResult',
+    # 空间回归
+    'spatial_lag_model',
+    'spatial_error_model',
+    'SpatialRegressionResult',
+    # 空间杜宾模型
+    'spatial_durbin_model',
+    'SpatialDurbinResult',
+    # 地理加权回归
+    'geographically_weighted_regression',
+    'GWRResult'
+]