aigroup-econ-mcp 0.3.3__tar.gz → 0.3.5__tar.gz

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aigroup-econ-mcp
-Version: 0.3.3
+Version: 0.3.5
 Summary: 专业计量经济学MCP工具 - 让大模型直接进行数据分析
 Project-URL: Homepage, https://github.com/aigroup/aigroup-econ-mcp
 Project-URL: Repository, https://github.com/aigroup/aigroup-econ-mcp.git

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aigroup-econ-mcp"
-version = "0.3.3"
+version = "0.3.5"
 description = "专业计量经济学MCP工具 - 让大模型直接进行数据分析"
 readme = "README.md"
 requires-python = ">=3.10"

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/src/aigroup_econ_mcp/__init__.py

@@ -10,7 +10,7 @@ AIGroup 计量经济学 MCP 服务
 - 模型诊断
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"
 __author__ = "AIGroup"
 __description__ = "专业计量经济学MCP工具 - 让大模型直接进行数据分析"
 

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/src/aigroup_econ_mcp/server.py

@@ -2203,7 +2203,7 @@ async def var_forecast(
                     text=f"VAR模型预测结果：\n"
                          f"预测步数: {steps}\n"
                          f"模型滞后阶数: {result['model_order']}\n"
-                         f"AIC = {result['model_aic']:.2f}, BIC = {result['model_bic']:.2f}\n"
+                         f"AIC = {result.get('model_aic', 0):.2f}, BIC = {result.get('model_bic', 0):.2f}\n"
                          f"各变量预测值已生成"
                 )
             ],
@@ -2621,7 +2621,7 @@ async def random_forest_regression_analysis(
                          f"平均绝对误差 = {result.mae:.4f}\n"
                          f"树的数量 = {result.n_estimators}\n"
                          f"最大深度 = {result.max_depth if result.max_depth != -1 else '无限制'}\n"
-                         f"袋外得分 = {result.oob_score:.4f if result.oob_score else 'N/A'}\n\n"
+                         f"袋外得分 = {result.oob_score:.4f if result.oob_score is not None else 'N/A'}\n\n"
                          f"特征重要性：\n" + "\n".join([
                              f"  {feature}: {importance:.4f}" 
                              for feature, importance in result.feature_importance.items()

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/src/aigroup_econ_mcp/tools/machine_learning.py

@@ -156,7 +156,7 @@ def random_forest_regression(
         feature_names=feature_names,
         feature_importance=feature_importance,
         n_estimators=n_estimators,
-        max_depth=max_depth if max_depth is not None else -1,  # -1表示无限制
+        max_depth=max_depth if max_depth is not None else 0,  # 0表示无限制
         oob_score=rf_model.oob_score_ if hasattr(rf_model, 'oob_score_') else None
     )
 

{aigroup_econ_mcp-0.3.3 → aigroup_econ_mcp-0.3.5}/src/aigroup_econ_mcp/tools/time_series.py

@@ -262,9 +262,9 @@ def garch_model(
         if not data:
             raise ValueError("Data cannot be empty")
         
-        # Reduced data length requirement from 50 to 30 observations
-        if len(data) < 30:
-            raise ValueError(f"GARCH model requires at least 30 observations, currently have {len(data)}")
+        # Reduced data length requirement from 50 to 20 observations
+        if len(data) < 20:
+            raise ValueError(f"GARCH模型至少需要20个观测点，当前只有{len(data)}个观测点")
         
         # Convert to return series (if data is not returns)
         series = pd.Series(data)
@@ -417,15 +417,33 @@ def impulse_response_analysis(
         df = pd.DataFrame(data)
         
         # Check data length
-        if len(df) < max_lags + 10:
-            raise ValueError(f"Data length ({len(df)}) insufficient, need at least {max_lags + 10} observations")
+        min_obs = max(max_lags + 10, 20)  # 确保足够的数据点
+        if len(df) < min_obs:
+            raise ValueError(f"数据长度({len(df)})不足，需要至少{min_obs}个观测点")
+        
+        # 数据平稳性检查
+        from statsmodels.tsa.stattools import adfuller
+        stationary_vars = []
+        for col in df.columns:
+            adf_result = adfuller(df[col].dropna())
+            if adf_result[1] < 0.05:  # p值 < 0.05 表示平稳
+                stationary_vars.append(col)
+        
+        if len(stationary_vars) < len(df.columns):
+            print(f"警告: 变量 {set(df.columns) - set(stationary_vars)} 可能非平稳，建议进行差分处理")
         
         # Fit VAR model
         model = VAR(df)
         
-        # Select optimal lag order
-        lag_order = model.select_order(maxlags=max_lags)
-        best_lag = lag_order.aic
+        # Select optimal lag order with error handling
+        try:
+            lag_order = model.select_order(maxlags=max_lags)
+            best_lag = lag_order.aic
+            if best_lag is None or best_lag == 0:
+                best_lag = 1  # 默认滞后阶数
+        except Exception as e:
+            print(f"滞后阶数选择失败，使用默认滞后阶数1: {e}")
+            best_lag = 1
         
         # Fit model with optimal lag
         fitted_model = model.fit(best_lag)
@@ -462,15 +480,8 @@ def impulse_response_analysis(
                 "model_order": best_lag
             }
         
-        return {
-            "impulse_responses": impulse_responses,
-            "orthogonalized": irf.orth_irfs.tolist() if hasattr(irf, 'orth_irfs') else None,
-            "cumulative_effects": irf.cum_effects.tolist() if hasattr(irf, 'cum_effects') else None,
-            "model_order": best_lag
-        }
-        
     except Exception as e:
-        raise ValueError(f"Impulse response analysis failed: {str(e)}")
+        raise ValueError(f"脉冲响应分析失败: {str(e)}")
 
 
 def variance_decomposition(
@@ -484,15 +495,33 @@ def variance_decomposition(
         df = pd.DataFrame(data)
         
         # Check data length
-        if len(df) < max_lags + 10:
-            raise ValueError(f"Data length ({len(df)}) insufficient, need at least {max_lags + 10} observations")
+        min_obs = max(max_lags + 10, 20)  # 确保足够的数据点
+        if len(df) < min_obs:
+            raise ValueError(f"数据长度({len(df)})不足，需要至少{min_obs}个观测点")
+        
+        # 数据平稳性检查
+        from statsmodels.tsa.stattools import adfuller
+        stationary_vars = []
+        for col in df.columns:
+            adf_result = adfuller(df[col].dropna())
+            if adf_result[1] < 0.05:  # p值 < 0.05 表示平稳
+                stationary_vars.append(col)
+        
+        if len(stationary_vars) < len(df.columns):
+            print(f"警告: 变量 {set(df.columns) - set(stationary_vars)} 可能非平稳，建议进行差分处理")
         
         # Fit VAR model
         model = VAR(df)
         
-        # Select optimal lag order
-        lag_order = model.select_order(maxlags=max_lags)
-        best_lag = lag_order.aic
+        # Select optimal lag order with error handling
+        try:
+            lag_order = model.select_order(maxlags=max_lags)
+            best_lag = lag_order.aic
+            if best_lag is None or best_lag == 0:
+                best_lag = 1  # 默认滞后阶数
+        except Exception as e:
+            print(f"滞后阶数选择失败，使用默认滞后阶数1: {e}")
+            best_lag = 1
         
         # Fit model with optimal lag
         fitted_model = model.fit(best_lag)
@@ -525,7 +554,7 @@ def variance_decomposition(
         }
         
     except Exception as e:
-        raise ValueError(f"Variance decomposition failed: {str(e)}")
+        raise ValueError(f"方差分解失败: {str(e)}")
 
 
 def vecm_model(
@@ -549,47 +578,66 @@ def vecm_model(
     try:
         # Data validation
         if not data:
-            raise ValueError("Data cannot be empty")
+            raise ValueError("数据不能为空")
         
         if len(data) < 2:
-            raise ValueError("VECM model requires at least 2 variables")
+            raise ValueError("VECM模型至少需要2个变量")
         
         # Convert to DataFrame
         df = pd.DataFrame(data)
         
         # Check data length
-        if len(df) < max_lags + 10:
-            raise ValueError(f"Data length ({len(df)}) insufficient, need at least {max_lags + 10} observations")
+        min_obs = max(max_lags + 10, 30)  # 确保足够的数据点
+        if len(df) < min_obs:
+            raise ValueError(f"数据长度({len(df)})不足，需要至少{min_obs}个观测点")
         
-        # Simplified implementation:
-        # Simplified implementation: use VAR model as base
-        # In practice, should use specialized VECM implementation
+        # 数据平稳性检查
+        from statsmodels.tsa.stattools import adfuller
+        stationary_vars = []
+        for col in df.columns:
+            adf_result = adfuller(df[col].dropna())
+            if adf_result[1] < 0.05:  # p值 < 0.05 表示平稳
+                stationary_vars.append(col)
+        
+        if len(stationary_vars) < len(df.columns):
+            print(f"警告: 变量 {set(df.columns) - set(stationary_vars)} 可能非平稳，建议进行差分处理")
+        
+        # 简化实现：使用VAR模型作为基础
+        # 在实际应用中，应该使用专门的VECM实现
         
         # Fit VAR model
         model = VAR(df)
-        lag_order = model.select_order(maxlags=max_lags)
-        best_lag = lag_order.aic
+        
+        # Select optimal lag order with error handling
+        try:
+            lag_order = model.select_order(maxlags=max_lags)
+            best_lag = lag_order.aic
+            if best_lag is None or best_lag == 0:
+                best_lag = 1  # 默认滞后阶数
+        except Exception as e:
+            print(f"滞后阶数选择失败，使用默认滞后阶数1: {e}")
+            best_lag = 1
         
         fitted_model = model.fit(best_lag)
         
-        # Build coefficients
+        # Build coefficients with proper error handling
         coefficients = {}
         for i, col in enumerate(df.columns):
             coefficients[col] = {}
             # Add constant term
-            coefficients[col]['const'] = 0.0  # Simplified implementation
+            coefficients[col]['const'] = 0.0  # 简化实现
             # Add error correction term
-            coefficients[col]['ecm'] = -0.1  # Simplified implementation
+            coefficients[col]['ecm'] = -0.1  # 简化实现
         
         # Build error correction terms
         error_correction = {}
         for col in df.columns:
-            error_correction[col] = -0.1  # Simplified implementation
+            error_correction[col] = -0.1  # 简化实现
         
-        # Build cointegration vectors
+        # Build cointegration vectors with proper rank handling
         cointegration_vectors = []
-        for i in range(coint_rank):
-            vector = [1.0] + [-0.5] * (len(df.columns) - 1)  # Simplified implementation
+        for i in range(min(coint_rank, len(df.columns))):  # 确保秩不超过变量数量
+            vector = [1.0] + [-0.5] * (len(df.columns) - 1)  # 简化实现
             cointegration_vectors.append(vector)
         
         return VECMModelResult(
@@ -603,7 +651,7 @@ def vecm_model(
         )
         
     except Exception as e:
-        raise ValueError(f"VECM model fitting failed: {str(e)}")
+        raise ValueError(f"VECM模型拟合失败: {str(e)}")
 
 
 def forecast_var(