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

econometrics/model_specification_diagnostics_robust_inference/diagnostic_tests/diagnostic_tests_model.py

@@ -0,0 +1,149 @@
+"""
+模型诊断测试 (Diagnostic Tests) 模块实现
+
+包括各种统计检验方法：
+- 异方差检验（White、Breusch-Pagan）
+- 自相关检验（Durbin-Watson、Ljung-Box）
+- 正态性检验（Jarque-Bera）
+- 多重共线性诊断（VIF）
+- 内生性检验（Durbin-Wu-Hausman）
+"""
+
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+import numpy as np
+import pandas as pd
+from scipy import stats
+import statsmodels.api as sm
+from statsmodels.stats.diagnostic import het_breuschpagan, het_white, acorr_ljungbox
+from statsmodels.stats.stattools import jarque_bera
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+
+from tools.decorators import with_file_support_decorator as econometric_tool, validate_input
+
+
+class DiagnosticTestsResult(BaseModel):
+    """模型诊断测试结果"""
+    het_breuschpagan_stat: Optional[float] = Field(None, description="Breusch-Pagan异方差检验统计量")
+    het_breuschpagan_pvalue: Optional[float] = Field(None, description="Breusch-Pagan异方差检验p值")
+    het_white_stat: Optional[float] = Field(None, description="White异方差检验统计量")
+    het_white_pvalue: Optional[float] = Field(None, description="White异方差检验p值")
+    dw_statistic: Optional[float] = Field(None, description="Durbin-Watson自相关检验统计量")
+    jb_statistic: Optional[float] = Field(None, description="Jarque-Bera正态性检验统计量")
+    jb_pvalue: Optional[float] = Field(None, description="Jarque-Bera正态性检验p值")
+    vif_values: Optional[List[float]] = Field(None, description="方差膨胀因子(VIF)")
+    feature_names: Optional[List[str]] = Field(None, description="特征名称")
+
+
+@econometric_tool("diagnostic_tests")
+@validate_input(data_type="econometric")
+def diagnostic_tests(
+    y_data: List[float],
+    x_data: List[List[float]], 
+    feature_names: Optional[List[str]] = None,
+    constant: bool = True
+) -> DiagnosticTestsResult:
+    """
+    执行多种模型诊断测试
+    
+    Args:
+        y_data: 因变量数据
+        x_data: 自变量数据
+        feature_names: 特征名称
+        constant: 是否包含常数项
+        
+    Returns:
+        DiagnosticTestsResult: 诊断测试结果
+    """
+    # 转换为numpy数组并确保浮点精度
+    y = np.asarray(y_data, dtype=np.float64)
+    X = np.asarray(x_data, dtype=np.float64)
+    
+    # 添加常数项
+    if constant:
+        X = sm.add_constant(X)
+        if feature_names:
+            feature_names = ["const"] + feature_names
+        else:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    else:
+        if not feature_names:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    
+    # 执行OLS回归
+    try:
+        ols_model = sm.OLS(y, X)
+        ols_results = ols_model.fit()
+    except Exception as e:
+        # 如果OLS失败，返回默认结果
+        return DiagnosticTestsResult(
+            het_breuschpagan_stat=None,
+            het_breuschpagan_pvalue=None,
+            het_white_stat=None,
+            het_white_pvalue=None,
+            dw_statistic=None,
+            jb_statistic=None,
+            jb_pvalue=None,
+            vif_values=None,
+            feature_names=feature_names[1:] if feature_names and len(feature_names) > 1 else None
+        )
+    
+    # 计算预测值和残差
+    y_pred = ols_results.fittedvalues
+    residuals = ols_results.resid
+    
+    # Breusch-Pagan异方差检验
+    try:
+        bp_stat, bp_pvalue, _, _ = het_breuschpagan(residuals, X)
+        bp_stat = float(bp_stat)
+        bp_pvalue = float(bp_pvalue)
+    except:
+        bp_stat = None
+        bp_pvalue = None
+    
+    # White异方差检验
+    try:
+        white_stat, white_pvalue, _, _ = het_white(residuals, X)
+        white_stat = float(white_stat)
+        white_pvalue = float(white_pvalue)
+    except:
+        white_stat = None
+        white_pvalue = None
+    
+    # Durbin-Watson自相关检验
+    try:
+        dw_stat = float(sm.stats.durbin_watson(residuals))
+    except:
+        dw_stat = None
+    
+    # Jarque-Bera正态性检验
+    try:
+        jb_stat, jb_pvalue, _, _ = jarque_bera(residuals)
+        jb_stat = float(jb_stat)
+        jb_pvalue = float(jb_pvalue)
+    except:
+        jb_stat = None
+        jb_pvalue = None
+    
+    # VIF计算（方差膨胀因子）
+    try:
+        vif_values = []
+        # 只对自变量计算VIF（跳过常数项）
+        for i in range(1 if constant else 0, X.shape[1]):
+            vif = variance_inflation_factor(X, i)
+            vif_values.append(float(vif))
+    except:
+        vif_values = None
+    
+    return DiagnosticTestsResult(
+        het_breuschpagan_stat=bp_stat,
+        het_breuschpagan_pvalue=bp_pvalue,
+        het_white_stat=white_stat,
+        het_white_pvalue=white_pvalue,
+        dw_statistic=dw_stat,
+        jb_statistic=jb_stat,
+        jb_pvalue=jb_pvalue,
+        vif_values=vif_values,
+        feature_names=feature_names[1:] if constant and feature_names and len(feature_names) > 1 else feature_names
+    )

econometrics/model_specification_diagnostics_robust_inference/generalized_least_squares/__init__.py

@@ -0,0 +1,15 @@
+"""
+广义最小二乘法 (Generalized Least Squares) 模块
+
+GLS方法实现
+"""
+
+from .gls_model import (
+    GLSResult,
+    gls_regression
+)
+
+__all__ = [
+    "GLSResult",
+    "gls_regression"
+]

econometrics/model_specification_diagnostics_robust_inference/generalized_least_squares/gls_model.py

@@ -0,0 +1,130 @@
+"""
+广义最小二乘法 (Generalized Least Squares, GLS) 模型实现
+"""
+
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+import numpy as np
+import pandas as pd
+from scipy import stats
+import statsmodels.api as sm
+
+from tools.decorators import with_file_support_decorator as econometric_tool, validate_input
+
+
+class GLSResult(BaseModel):
+    """GLS回归结果"""
+    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="置信区间上界")
+    r_squared: float = Field(..., description="R方")
+    adj_r_squared: float = Field(..., description="调整R方")
+    f_statistic: float = Field(..., description="F统计量")
+    f_p_value: float = Field(..., description="F统计量p值")
+    n_obs: int = Field(..., description="观测数量")
+    feature_names: List[str] = Field(..., description="特征名称")
+    log_likelihood: float = Field(..., description="对数似然值")
+
+
+@econometric_tool("gls_regression")
+@validate_input(data_type="econometric")
+def gls_regression(
+    y_data: List[float],
+    x_data: List[List[float]], 
+    sigma: Optional[List[List[float]]] = None,
+    feature_names: Optional[List[str]] = None,
+    constant: bool = True,
+    confidence_level: float = 0.95
+) -> GLSResult:
+    """
+    广义最小二乘法回归
+    
+    Args:
+        y_data: 因变量数据
+        x_data: 自变量数据
+        sigma: 误差项协方差矩阵（可选，如未提供则使用单位矩阵）
+        feature_names: 特征名称
+        constant: 是否包含常数项
+        confidence_level: 置信水平
+        
+    Returns:
+        GLSResult: GLS回归结果
+    """
+    # 转换为numpy数组
+    y = np.asarray(y_data, dtype=np.float64)
+    X = np.asarray(x_data, dtype=np.float64)
+    
+    # 添加常数项
+    if constant:
+        X = sm.add_constant(X)
+        if feature_names:
+            feature_names = ["const"] + feature_names
+        else:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    else:
+        if not feature_names:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    
+    # 检查数据维度
+    n, k = X.shape
+    if n <= k:
+        raise ValueError(f"观测数量({n})必须大于变量数量({k})")
+    
+    # 如果未提供协方差矩阵，则使用单位矩阵（等价于OLS）
+    if sigma is None:
+        model = sm.GLS(y, X)
+    else:
+        sigma_array = np.asarray(sigma, dtype=np.float64)
+        # 检查协方差矩阵维度
+        if sigma_array.shape != (n, n):
+            raise ValueError(f"协方差矩阵sigma的维度必须是({n}, {n})，当前是{sigma_array.shape}")
+        model = sm.GLS(y, X, sigma=sigma_array)
+    
+    # 拟合模型
+    try:
+        results = model.fit()
+    except Exception as e:
+        raise ValueError(f"无法拟合GLS模型: {str(e)}")
+    
+    # 提取结果
+    coefficients = results.params.tolist()
+    std_errors = results.bse.tolist()
+    t_values = results.tvalues.tolist()
+    p_values = results.pvalues.tolist()
+    
+    # 计算置信区间
+    alpha = 1 - confidence_level
+    conf_int = results.conf_int(alpha=alpha)
+    conf_int_lower = conf_int[:, 0].tolist()
+    conf_int_upper = conf_int[:, 1].tolist()
+    
+    # 其他统计量
+    r_squared = float(results.rsquared)
+    adj_r_squared = float(results.rsquared_adj)
+    
+    # F统计量
+    f_statistic = float(results.fvalue) if not np.isnan(results.fvalue) else 0.0
+    f_p_value = float(results.f_pvalue) if not np.isnan(results.f_pvalue) else 1.0
+    
+    # 对数似然值
+    log_likelihood = float(results.llf)
+
+    return GLSResult(
+        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,
+        r_squared=r_squared,
+        adj_r_squared=adj_r_squared,
+        f_statistic=f_statistic,
+        f_p_value=f_p_value,
+        n_obs=int(results.nobs),
+        feature_names=feature_names,
+        log_likelihood=log_likelihood
+    )

econometrics/model_specification_diagnostics_robust_inference/model_selection/__init__.py

@@ -0,0 +1,18 @@
+"""
+模型选择 (Model Selection) 模块
+
+包括：
+- 信息准则（AIC/BIC/HQIC）
+- 交叉验证（K折、留一法）
+- 格兰杰因果检验
+"""
+
+from .model_selection_model import (
+    ModelSelectionResult,
+    model_selection_criteria
+)
+
+__all__ = [
+    "ModelSelectionResult",
+    "model_selection_criteria"
+]

econometrics/model_specification_diagnostics_robust_inference/model_selection/model_selection_model.py

@@ -0,0 +1,286 @@
+"""
+模型选择 (Model Selection) 模块实现
+
+包括：
+- 信息准则（AIC/BIC/HQIC）
+- 交叉验证（K折、留一法）
+- 格兰杰因果检验
+"""
+
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+import numpy as np
+import pandas as pd
+from scipy import stats
+import statsmodels.api as sm
+from statsmodels.tsa.stattools import grangercausalitytests
+
+from tools.decorators import with_file_support_decorator as econometric_tool, validate_input
+
+
+class GrangerCausalityResult(BaseModel):
+    """格兰杰因果检验结果"""
+    f_statistic: float = Field(..., description="F统计量")
+    p_value: float = Field(..., description="p值")
+    lag_order: int = Field(..., description="滞后阶数")
+    n_obs: int = Field(..., description="观测数量")
+    dependent_variable: str = Field(..., description="因变量")
+    independent_variable: str = Field(..., description="格兰杰原因变量")
+
+
+class ModelSelectionResult(BaseModel):
+    """模型选择结果"""
+    aic: float = Field(..., description="赤池信息准则 (AIC)")
+    bic: float = Field(..., description="贝叶斯信息准则 (BIC)")
+    hqic: float = Field(..., description="汉南-奎因信息准则 (HQIC)")
+    r_squared: float = Field(..., description="R方")
+    adj_r_squared: float = Field(..., description="调整R方")
+    log_likelihood: float = Field(..., description="对数似然值")
+    n_obs: int = Field(..., description="观测数量")
+    n_params: int = Field(..., description="参数数量")
+    cv_score: Optional[float] = Field(None, description="交叉验证得分")
+
+
+@econometric_tool("granger_causality_test")
+@validate_input(data_type="timeseries")
+def granger_causality_test(
+    x_data: List[float],
+    y_data: List[float], 
+    max_lag: int = 1,
+    add_constant: bool = True
+) -> GrangerCausalityResult:
+    """
+    格兰杰因果检验
+    
+    Args:
+        x_data: 可能的格兰杰原因变量
+        y_data: 因变量
+        max_lag: 最大滞后阶数
+        add_constant: 是否添加常数项
+        
+    Returns:
+        GrangerCausalityResult: 格兰杰因果检验结果
+    """
+    # 转换为numpy数组
+    x = np.asarray(x_data, dtype=np.float64)
+    y = np.asarray(y_data, dtype=np.float64)
+    
+    # 检查数据长度
+    if len(x) != len(y):
+        raise ValueError("x_data和y_data的长度必须相同")
+    
+    if len(x) <= max_lag:
+        raise ValueError("数据长度必须大于滞后阶数")
+    
+    # 构建数据框用于statsmodels
+    data = pd.DataFrame({'y': y, 'x': x})
+    
+    # 执行格兰杰因果检验
+    try:
+        # grangercausalitytests返回一个字典，键为滞后阶数
+        test_result = grangercausalitytests(data, max_lag, addconst=add_constant, verbose=False)
+        
+        # 获取指定滞后阶数的结果（使用最大滞后阶数）
+        lag_order = max_lag
+        test_stats = test_result[lag_order][0]
+        
+        # 提取F统计量和p值（使用ssr F-test）
+        f_statistic = test_stats['F test']
+        f_stat = f_statistic[0]  # F统计量
+        p_value = f_statistic[1]  # p值
+        
+    except Exception as e:
+        # 如果检验失败，返回默认值
+        f_stat = 0.0
+        p_value = 1.0
+        lag_order = max_lag
+    
+    return GrangerCausalityResult(
+        f_statistic=float(f_stat),
+        p_value=float(p_value),
+        lag_order=lag_order,
+        n_obs=len(y) - lag_order,  # 考虑滞后后的实际观测数
+        dependent_variable="y",
+        independent_variable="x"
+    )
+
+
+@econometric_tool("model_selection_criteria")
+@validate_input(data_type="econometric")
+def model_selection_criteria(
+    y_data: List[float],
+    x_data: List[List[float]], 
+    feature_names: Optional[List[str]] = None,
+    constant: bool = True,
+    cv_folds: Optional[int] = None
+) -> ModelSelectionResult:
+    """
+    计算模型选择信息准则
+    
+    Args:
+        y_data: 因变量数据
+        x_data: 自变量数据
+        feature_names: 特征名称
+        constant: 是否包含常数项
+        cv_folds: 交叉验证折数 (None表示不进行交叉验证，-1表示留一法)
+        
+    Returns:
+        ModelSelectionResult: 模型选择结果
+    """
+    # 转换为numpy数组
+    y = np.array(y_data)
+    X = np.array(x_data)
+    
+    # 添加常数项
+    if constant:
+        X = sm.add_constant(X)
+        if feature_names:
+            feature_names = ["const"] + feature_names
+        else:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    else:
+        if not feature_names:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    
+    # 执行OLS回归
+    try:
+        model = sm.OLS(y, X)
+        results = model.fit()
+    except Exception as e:
+        raise ValueError(f"无法拟合模型: {str(e)}")
+    
+    # 提取统计量
+    n = int(results.nobs)
+    k = len(results.params)
+    r_squared = float(results.rsquared)
+    adj_r_squared = float(results.rsquared_adj)
+    log_likelihood = float(results.llf)
+    aic = float(results.aic)
+    bic = float(results.bic)
+    
+    # 计算HQIC (statsmodels中没有直接提供HQIC)
+    if n > 1 and np.log(n) != 0:
+        hqic = -2 * log_likelihood + 2 * k * np.log(np.log(n))
+    else:
+        hqic = np.inf
+    
+    # 交叉验证
+    cv_score = None
+    if cv_folds is not None:
+        cv_score = _cross_validation(y, X, cv_folds)
+    
+    return ModelSelectionResult(
+        aic=aic,
+        bic=bic,
+        hqic=float(hqic) if np.isfinite(hqic) else np.inf,
+        r_squared=r_squared,
+        adj_r_squared=adj_r_squared,
+        log_likelihood=log_likelihood,
+        n_obs=n,
+        n_params=k,
+        cv_score=float(cv_score) if cv_score is not None else None
+    )
+
+
+def _cross_validation(y: np.ndarray, X: np.ndarray, folds: Optional[int]) -> float:
+    """
+    执行交叉验证
+    
+    Args:
+        y: 因变量
+        X: 自变量矩阵
+        folds: 折数 (-1表示留一法，其他正数表示K折交叉验证)
+        
+    Returns:
+        float: 交叉验证得分 (平均MSE)
+    """
+    n = len(y)
+    
+    if folds is None or folds == 0:
+        return None
+    
+    if folds == -1 or folds >= n:
+        # 留一法交叉验证
+        folds = n
+    
+    if folds <= 1 or X.shape[0] != n:
+        return None
+    
+    # 检查是否有足够的数据进行训练和测试
+    if X.shape[0] < X.shape[1]:
+        return None
+    
+    # 创建折叠索引
+    indices = np.arange(n)
+    np.random.seed(42)  # 固定随机种子以确保结果可重现
+    np.random.shuffle(indices)
+    
+    # 计算每折的大小
+    fold_sizes = np.full(folds, n // folds)
+    fold_sizes[:n % folds] += 1
+    
+    current = 0
+    mse_scores = []
+    
+    for fold_size in fold_sizes:
+        start, stop = current, current + fold_size
+        test_idx = indices[start:stop]
+        train_idx = np.concatenate([indices[:start], indices[stop:]])
+        
+        # 分割数据
+        X_train, X_test = X[train_idx], X[test_idx]
+        y_train, y_test = y[train_idx], y[test_idx]
+        
+        try:
+            # 检查是否有足够的数据进行训练和测试
+            if X_train.shape[0] < X_train.shape[1] or X_train.shape[0] == 0 or X_test.shape[0] == 0:
+                continue
+                
+            # 训练模型，使用带正则化的求解方法
+            try:
+                # 使用statsmodels进行更稳定的回归
+                train_model = sm.OLS(y_train, X_train)
+                train_results = train_model.fit()
+                beta_train = train_results.params
+            except:
+                # 如果statsmodels失败，使用numpy的最小二乘法
+                # 添加正则化防止矩阵奇异
+                XtX = X_train.T @ X_train
+                if XtX.shape[0] > 0:
+                    # 添加一个小的正则化项
+                    reg_param = 1e-10 * np.trace(XtX) / XtX.shape[0] if np.trace(XtX) > 0 and XtX.shape[0] > 0 else 1e-10
+                    XtX_reg = XtX + reg_param * np.eye(XtX.shape[0])
+                    try:
+                        beta_train = np.linalg.solve(XtX_reg, X_train.T @ y_train)
+                    except np.linalg.LinAlgError:
+                        # 如果仍然失败，使用伪逆
+                        beta_train = np.linalg.pinv(XtX_reg) @ X_train.T @ y_train
+                else:
+                    continue
+            
+            # 预测
+            try:
+                y_pred = X_test @ beta_train
+            except:
+                continue
+            
+            # 检查预测值是否有效
+            if not np.all(np.isfinite(y_pred)):
+                continue
+                
+            # 计算MSE
+            mse = np.mean((y_test - y_pred) ** 2)
+            # 检查MSE是否有效
+            if np.isfinite(mse):
+                mse_scores.append(mse)
+        except (np.linalg.LinAlgError, ValueError, ZeroDivisionError):
+            # 如果出现数值问题，跳过这一折
+            pass
+        except Exception:
+            # 捕获其他可能的异常
+            pass
+            
+        current = stop
+    
+    return np.mean(mse_scores) if mse_scores and len(mse_scores) > 0 else None

econometrics/model_specification_diagnostics_robust_inference/regularization/__init__.py

@@ -0,0 +1,15 @@
+"""
+正则化方法 (Regularization Methods) 模块
+
+包括岭回归、LASSO和弹性网络等方法，用于处理多重共线性/高维数据
+"""
+
+from .regularization_model import (
+    RegularizationResult,
+    regularized_regression
+)
+
+__all__ = [
+    "RegularizationResult",
+    "regularized_regression"
+]