aigroup-econ-mcp 0.1.0__py3-none-any.whl

aigroup_econ_mcp/tools/regression.py

@@ -0,0 +1,214 @@
+"""
+回归分析工具
+"""
+
+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

@@ -0,0 +1,134 @@
+"""
+统计分析工具
+"""
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+from typing import Dict, List, Any
+from pydantic import BaseModel
+
+
+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: List[float]) -> DescriptiveStats:
+    """计算描述性统计量"""
+    series = pd.Series(data)
+
+    return DescriptiveStats(
+        mean=series.mean(),
+        median=series.median(),
+        std=series.std(),
+        min=series.min(),
+        max=series.max(),
+        skewness=series.skew(),
+        kurtosis=series.kurtosis(),
+        count=len(series)
+    )
+
+
+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
+        }
+
+    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
+        }
+    }

aigroup_econ_mcp/tools/time_series.py

@@ -0,0 +1,260 @@
+"""
+时间序列分析工具
+"""
+
+import numpy as np
+import pandas as pd
+from typing import List, Dict, Any, Optional, Tuple
+from pydantic import BaseModel
+import statsmodels.api as sm
+from statsmodels.tsa.stattools import adfuller, kpss, acf, pacf
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+
+
+class StationarityTest(BaseModel):
+    """平稳性检验结果"""
+    adf_statistic: float
+    adf_pvalue: float
+    adf_critical_values: Dict[str, float]
+    kpss_statistic: float
+    kpss_pvalue: float
+    is_stationary: bool
+
+
+class ACFPACFResult(BaseModel):
+    """自相关分析结果"""
+    acf_values: List[float]
+    pacf_values: List[float]
+    acf_confidence: List[Tuple[float, float]]
+    pacf_confidence: List[Tuple[float, float]]
+
+
+class ARIMAResult(BaseModel):
+    """ARIMA模型结果"""
+    order: Tuple[int, int, int]
+    aic: float
+    bic: float
+    coefficients: Dict[str, float]
+    fitted_values: List[float]
+    residuals: List[float]
+    forecast: Optional[List[float]] = None
+
+
+def check_stationarity(data: List[float], max_lags: int = None) -> StationarityTest:
+    """平稳性检验（ADF和KPSS）"""
+    series = pd.Series(data)
+
+    # ADF检验
+    adf_result = adfuller(series, maxlag=max_lags, autolag='AIC')
+    adf_stat, adf_pvalue = adf_result[0], adf_result[1]
+    adf_critical = adf_result[4]
+
+    # KPSS检验
+    kpss_result = kpss(series, regression='c', nlags='auto')
+    kpss_stat, kpss_pvalue = kpss_result[0], kpss_result[1]
+
+    # 综合判断平稳性
+    is_stationary = (adf_pvalue < 0.05) and (kpss_pvalue > 0.05)
+
+    return StationarityTest(
+        adf_statistic=adf_stat,
+        adf_pvalue=adf_pvalue,
+        adf_critical_values=adf_critical,
+        kpss_statistic=kpss_stat,
+        kpss_pvalue=kpss_pvalue,
+        is_stationary=is_stationary
+    )
+
+
+def calculate_acf_pacf(
+    data: List[float],
+    nlags: int = 20,
+    alpha: float = 0.05
+) -> ACFPACFResult:
+    """计算自相关和偏自相关函数"""
+    series = pd.Series(data)
+
+    # 计算ACF和PACF
+    acf_values = acf(series, nlags=nlags, alpha=alpha)
+    pacf_values = pacf(series, nlags=nlags, alpha=alpha)
+
+    # 构建置信区间
+    acf_conf = []
+    pacf_conf = []
+
+    for i in range(len(acf_values[1])):
+        acf_conf.append((acf_values[1][i][0], acf_values[1][i][1]))
+        pacf_conf.append((pacf_values[1][i][0], pacf_values[1][i][1]))
+
+    return ACFPACFResult(
+        acf_values=acf_values[0].tolist(),
+        pacf_values=pacf_values[0].tolist(),
+        acf_confidence=acf_conf,
+        pacf_confidence=pacf_conf
+    )
+
+
+def fit_arima_model(
+    data: List[float],
+    order: Tuple[int, int, int] = (1, 1, 1),
+    seasonal_order: Tuple[int, int, int, int] = (0, 0, 0, 0)
+) -> ARIMAResult:
+    """拟合ARIMA模型"""
+    series = pd.Series(data)
+
+    try:
+        if seasonal_order != (0, 0, 0, 0):
+            # 季节性ARIMA
+            model = SARIMAX(series, order=order, seasonal_order=seasonal_order)
+        else:
+            # 普通ARIMA
+            model = ARIMA(series, order=order)
+
+        fitted_model = model.fit()
+
+        return ARIMAResult(
+            order=order,
+            aic=fitted_model.aic,
+            bic=fitted_model.bic,
+            coefficients=fitted_model.params.to_dict(),
+            fitted_values=fitted_model.fittedvalues.tolist(),
+            residuals=fitted_model.resid.tolist()
+        )
+
+    except Exception as e:
+        raise ValueError(f"ARIMA模型拟合失败: {str(e)}")
+
+
+def find_best_arima_order(
+    data: List[float],
+    max_p: int = 3,
+    max_d: int = 2,
+    max_q: int = 3,
+    seasonal: bool = False,
+    max_P: int = 1,
+    max_D: int = 1,
+    max_Q: int = 1,
+    m: int = 12
+) -> Dict[str, Any]:
+    """自动寻找最佳ARIMA模型阶数"""
+    series = pd.Series(data)
+    best_aic = float('inf')
+    best_order = (0, 0, 0)
+    best_seasonal_order = (0, 0, 0, 0)
+    best_model = None
+
+    # 非季节性ARIMA
+    if not seasonal:
+        for p in range(max_p + 1):
+            for d in range(max_d + 1):
+                for q in range(max_q + 1):
+                    try:
+                        model = ARIMA(series, order=(p, d, q))
+                        fitted_model = model.fit()
+                        if fitted_model.aic < best_aic:
+                            best_aic = fitted_model.aic
+                            best_order = (p, d, q)
+                            best_model = fitted_model
+                    except:
+                        continue
+
+    # 季节性ARIMA
+    else:
+        for p in range(max_p + 1):
+            for d in range(max_d + 1):
+                for q in range(max_q + 1):
+                    for P in range(max_P + 1):
+                        for D in range(max_D + 1):
+                            for Q in range(max_Q + 1):
+                                try:
+                                    seasonal_order = (P, D, Q, m)
+                                    model = SARIMAX(series, order=(p, d, q), seasonal_order=seasonal_order)
+                                    fitted_model = model.fit()
+                                    if fitted_model.aic < best_aic:
+                                        best_aic = fitted_model.aic
+                                        best_order = (p, d, q)
+                                        best_seasonal_order = seasonal_order
+                                        best_model = fitted_model
+                                except:
+                                    continue
+
+    if best_model is None:
+        raise ValueError("无法找到合适的ARIMA模型")
+
+    return {
+        "best_order": best_order,
+        "best_seasonal_order": best_seasonal_order if seasonal else None,
+        "best_aic": best_aic,
+        "best_bic": best_model.bic,
+        "coefficients": best_model.params.to_dict(),
+        "model_summary": str(best_model.summary())
+    }
+
+
+def decompose_time_series(
+    data: List[float],
+    model: str = "additive",
+    period: Optional[int] = None
+) -> Dict[str, List[float]]:
+    """时间序列分解"""
+    series = pd.Series(data)
+
+    if period is None:
+        # 自动检测周期（简单方法）
+        from statsmodels.tsa.seasonal import seasonal_decompose
+        decomposition = seasonal_decompose(series, model=model, extrapolate_trend='freq')
+
+        return {
+            "trend": decomposition.trend.fillna(0).tolist(),
+            "seasonal": decomposition.seasonal.fillna(0).tolist(),
+            "residual": decomposition.resid.fillna(0).tolist(),
+            "observed": decomposition.observed.tolist()
+        }
+    else:
+        # 指定周期的分解
+        decomposition = seasonal_decompose(series, model=model, period=period)
+
+        return {
+            "trend": decomposition.trend.fillna(0).tolist(),
+            "seasonal": decomposition.seasonal.fillna(0).tolist(),
+            "residual": decomposition.resid.fillna(0).tolist(),
+            "observed": decomposition.observed.tolist()
+        }
+
+
+def forecast_arima(
+    data: List[float],
+    order: Tuple[int, int, int] = (1, 1, 1),
+    steps: int = 10,
+    seasonal_order: Tuple[int, int, int, int] = (0, 0, 0, 0)
+) -> Dict[str, Any]:
+    """ARIMA模型预测"""
+    series = pd.Series(data)
+
+    try:
+        if seasonal_order != (0, 0, 0, 0):
+            model = SARIMAX(series, order=order, seasonal_order=seasonal_order)
+        else:
+            model = ARIMA(series, order=order)
+
+        fitted_model = model.fit()
+
+        # 生成预测
+        forecast_result = fitted_model.forecast(steps=steps)
+        forecast_values = forecast_result.tolist()
+
+        # 预测置信区间
+        pred_conf = fitted_model.get_forecast(steps=steps)
+        conf_int = pred_conf.conf_int()
+
+        return {
+            "forecast": forecast_values,
+            "conf_int_lower": conf_int.iloc[:, 0].tolist(),
+            "conf_int_upper": conf_int.iloc[:, 1].tolist(),
+            "model_aic": fitted_model.aic,
+            "model_bic": fitted_model.bic
+        }
+
+    except Exception as e:
+        raise ValueError(f"ARIMA预测失败: {str(e)}")