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

aigroup_econ_mcp/tools/regression.py

@@ -1,214 +0,0 @@
-"""
-回归分析工具
-"""
-
-import numpy as np
-import pandas as pd
-import statsmodels.api as sm
-from typing import List, Dict, Any, Optional
-from pydantic import BaseModel
-
-
-class OLSResult(BaseModel):
-    """OLS回归结果"""
-    coefficients: Dict[str, Dict[str, float]]
-    rsquared: float
-    rsquared_adj: float
-    f_statistic: float
-    f_pvalue: float
-    aic: float
-    bic: float
-    n_obs: int
-
-
-class DiagnosticTests(BaseModel):
-    """模型诊断结果"""
-    jb_statistic: float
-    jb_pvalue: float
-    bp_statistic: float
-    bp_pvalue: float
-    dw_statistic: float
-    vif: Dict[str, float]
-
-
-def perform_ols_regression(
-    y: List[float],
-    X: List[List[float]],
-    feature_names: Optional[List[str]] = None,
-    add_constant: bool = True
-) -> OLSResult:
-    """执行OLS回归分析"""
-    # 准备数据
-    X_matrix = np.array(X)
-    y_vector = np.array(y)
-
-    if add_constant:
-        X_matrix = sm.add_constant(X_matrix)
-
-    # 拟合模型
-    model = sm.OLS(y_vector, X_matrix).fit()
-
-    # 构建结果
-    result = OLSResult(
-        coefficients={},
-        rsquared=model.rsquared,
-        rsquared_adj=model.rsquared_adj,
-        f_statistic=model.fvalue,
-        f_pvalue=model.f_pvalue,
-        aic=model.aic,
-        bic=model.bic,
-        n_obs=model.nobs
-    )
-
-    # 添加系数详情
-    conf_int = model.conf_int()
-    for i, coef in enumerate(model.params):
-        var_name = "const" if i == 0 and add_constant else feature_names[i-1] if feature_names else f"x{i}"
-        result.coefficients[var_name] = {
-            "coef": coef,
-            "std_err": model.bse[i],
-            "t_value": model.tvalues[i],
-            "p_value": model.pvalues[i],
-            "ci_lower": conf_int[i][0],
-            "ci_upper": conf_int[i][1]
-        }
-
-    return result
-
-
-def calculate_vif(X: List[List[float]], feature_names: Optional[List[str]] = None) -> Dict[str, float]:
-    """计算方差膨胀因子(VIF)"""
-    X_matrix = np.array(X)
-
-    # 添加常数项用于VIF计算
-    X_with_const = sm.add_constant(X_matrix)
-
-    if feature_names is None:
-        feature_names = [f"x{i}" for i in range(X_matrix.shape[1])]
-
-    # 计算每个变量的VIF
-    vif_values = {}
-
-    for i in range(1, X_with_const.shape[1]):  # 跳过常数项
-        var_name = feature_names[i-1] if i-1 < len(feature_names) else f"x{i-1}"
-
-        # 将当前变量作为因变量，其他作为自变量
-        y_temp = X_with_const[:, i]
-        X_temp = np.delete(X_with_const, i, axis=1)
-
-        # 拟合辅助回归
-        aux_model = sm.OLS(y_temp, X_temp).fit()
-        r_squared = aux_model.rsquared
-
-        # 计算VIF
-        if r_squared < 1:
-            vif = 1 / (1 - r_squared)
-        else:
-            vif = float('inf')
-
-        vif_values[var_name] = vif
-
-    return vif_values
-
-
-def run_diagnostic_tests(
-    y: List[float],
-    X: List[List[float]],
-    residuals: Optional[List[float]] = None
-) -> DiagnosticTests:
-    """运行模型诊断检验"""
-    X_matrix = np.array(X)
-    y_vector = np.array(y)
-
-    # 拟合模型获取残差
-    if residuals is None:
-        X_with_const = sm.add_constant(X_matrix)
-        model = sm.OLS(y_vector, X_with_const).fit()
-        residuals = model.resid
-
-    # Jarque-Bera正态性检验
-    jb_stat, jb_p_value, _, _ = sm.stats.stattools.jarque_bera(residuals)
-
-    # Breusch-Pagan异方差检验
-    X_with_const = sm.add_constant(X_matrix)
-    bp_stat, bp_p_value, _, _ = sm.stats.diagnostic.het_breuschpagan(residuals, X_with_const)
-
-    # Durbin-Watson序列相关检验
-    dw_stat = sm.stats.stattools.durbin_watson(residuals)
-
-    # 计算VIF
-    vif_values = calculate_vif(X_matrix)
-
-    return DiagnosticTests(
-        jb_statistic=jb_stat,
-        jb_pvalue=jb_p_value,
-        bp_statistic=bp_stat,
-        bp_pvalue=bp_p_value,
-        dw_statistic=dw_stat,
-        vif=vif_values
-    )
-
-
-def stepwise_regression(
-    y: List[float],
-    X: List[List[float]],
-    feature_names: List[str],
-    direction: str = "both",
-    alpha_in: float = 0.05,
-    alpha_out: float = 0.10
-) -> Dict[str, Any]:
-    """逐步回归（简化版本）"""
-    X_matrix = np.array(X)
-    y_vector = np.array(y)
-
-    # 为了简化，这里返回所有变量的模型
-    # 实际的逐步回归需要更复杂的实现
-    X_with_const = sm.add_constant(X_matrix)
-    final_model = sm.OLS(y_vector, X_with_const).fit()
-
-    # 找出显著的变量（p值 < alpha_in）
-    significant_features = []
-    significant_indices = []
-
-    for i, p_val in enumerate(final_model.pvalues[1:], 1):  # 跳过常数项
-        if p_val < alpha_in:
-            significant_features.append(feature_names[i-1])
-            significant_indices.append(i)
-
-    # 如果有显著变量，返回只包含显著变量的模型
-    if significant_indices:
-        X_significant = sm.add_constant(X_matrix[:, [i-1 for i in significant_indices]])
-        significant_model = sm.OLS(y_vector, X_significant).fit()
-
-        return {
-            "selected_features": significant_features,
-            "model_summary": {
-                "rsquared": significant_model.rsquared,
-                "rsquared_adj": significant_model.rsquared_adj,
-                "aic": significant_model.aic,
-                "bic": significant_model.bic,
-                "f_statistic": significant_model.fvalue,
-                "f_pvalue": significant_model.f_pvalue
-            },
-            "coefficients": dict(zip(
-                ["const"] + significant_features,
-                zip(significant_model.params, significant_model.pvalues)
-            ))
-        }
-    else:
-        # 如果没有显著变量，返回全模型
-        return {
-            "selected_features": feature_names,
-            "model_summary": {
-                "rsquared": final_model.rsquared,
-                "rsquared_adj": final_model.rsquared_adj,
-                "aic": final_model.aic,
-                "bic": final_model.bic,
-                "f_statistic": final_model.fvalue,
-                "f_pvalue": final_model.f_pvalue
-            },
-            "coefficients": dict(zip(
-                ["const"] + feature_names,
-                zip(final_model.params, final_model.pvalues)
-            ))
-        }

aigroup_econ_mcp/tools/statistics.py

@@ -1,154 +0,0 @@
-"""
-统计分析工具
-"""
-
-import numpy as np
-import pandas as pd
-from scipy import stats
-from typing import Dict, List, Any
-from pydantic import BaseModel
-import statsmodels.api as sm
-
-
-class DescriptiveStats(BaseModel):
-    """描述性统计结果"""
-    mean: float
-    median: float
-    std: float
-    min: float
-    max: float
-    skewness: float
-    kurtosis: float
-    count: int
-
-
-class CorrelationResult(BaseModel):
-    """相关性分析结果"""
-    correlation_matrix: Dict[str, Dict[str, float]]
-    method: str
-
-
-def calculate_descriptive_stats(data: Dict[str, List[float]]) -> Dict[str, Dict[str, Any]]:
-    """计算多变量描述性统计量"""
-    results = {}
-    for var_name, var_data in data.items():
-        # 使用numpy计算统计量，避免pandas问题
-        arr = np.array(var_data, dtype=float)
-        
-        stats_result = DescriptiveStats(
-            mean=float(np.mean(arr)),
-            median=float(np.median(arr)),
-            std=float(np.std(arr)),
-            min=float(np.min(arr)),
-            max=float(np.max(arr)),
-            skewness=float(stats.skew(arr)),
-            kurtosis=float(stats.kurtosis(arr)),
-            count=len(arr)
-        )
-        # 转换为字典格式
-        results[var_name] = stats_result.dict()
-    return results
-
-
-def calculate_correlation_matrix(
-    data: Dict[str, List[float]],
-    method: str = "pearson"
-) -> CorrelationResult:
-    """计算相关系数矩阵"""
-    df = pd.DataFrame(data)
-    corr_matrix = df.corr(method=method)
-
-    return CorrelationResult(
-        correlation_matrix=corr_matrix.to_dict(),
-        method=method
-    )
-
-
-def perform_hypothesis_test(
-    data1: List[float],
-    data2: List[float] = None,
-    test_type: str = "t_test",
-    alpha: float = 0.05
-) -> Dict[str, Any]:
-    """执行假设检验"""
-    if test_type == "t_test":
-        if data2 is None:
-            # 单样本t检验
-            t_stat, p_value = stats.ttest_1samp(data1, 0)
-            test_name = "单样本t检验"
-        else:
-            # 双样本t检验
-            t_stat, p_value = stats.ttest_ind(data1, data2)
-            test_name = "双样本t检验"
-
-        return {
-            "test_type": test_name,
-            "statistic": t_stat,
-            "p_value": p_value,
-            "significant": p_value < alpha,
-            "alpha": alpha
-        }
-
-    elif test_type == "f_test":
-        # F检验（方差齐性检验）
-        if data2 is None:
-            raise ValueError("F检验需要两组数据")
-
-        f_stat, p_value = stats.f_oneway(data1, data2)
-        return {
-            "test_type": "F检验",
-            "statistic": f_stat,
-            "p_value": p_value,
-            "significant": p_value < alpha,
-            "alpha": alpha
-        }
-
-    elif test_type == "chi_square":
-        # 卡方检验
-        # 这里简化实现，实际需要频数数据
-        chi2_stat, p_value = stats.chisquare(data1)
-        return {
-            "test_type": "卡方检验",
-            "statistic": chi2_stat,
-            "p_value": p_value,
-            "significant": p_value < alpha,
-            "alpha": alpha
-        }
-
-    elif test_type == "adf":
-        # ADF单位根检验
-        from statsmodels.tsa.stattools import adfuller
-        adf_result = adfuller(data1)
-        return {
-            "test_type": "ADF单位根检验",
-            "statistic": adf_result[0],
-            "p_value": adf_result[1],
-            "critical_values": adf_result[4],
-            "significant": adf_result[1] < alpha,
-            "alpha": alpha
-        }
-    
-    else:
-        raise ValueError(f"不支持的检验类型: {test_type}")
-
-
-def normality_test(data: List[float]) -> Dict[str, Any]:
-    """正态性检验"""
-    # Shapiro-Wilk检验
-    shapiro_stat, shapiro_p = stats.shapiro(data)
-
-    # Kolmogorov-Smirnov检验
-    ks_stat, ks_p = stats.kstest(data, 'norm', args=(np.mean(data), np.std(data)))
-
-    return {
-        "shapiro_wilk": {
-            "statistic": shapiro_stat,
-            "p_value": shapiro_p,
-            "normal": shapiro_p > 0.05
-        },
-        "kolmogorov_smirnov": {
-            "statistic": ks_stat,
-            "p_value": ks_p,
-            "normal": ks_p > 0.05
-        }
-    }