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

aigroup_econ_mcp/tools/time_series.py

@@ -1,667 +0,0 @@
-
-"""
-Time series analysis tools - simplified version
-"""
-
-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
-from statsmodels.tsa.vector_ar.var_model import VAR
-
-
-class StationarityTest(BaseModel):
-    """Stationarity test results"""
-    adf_statistic: float
-    adf_pvalue: float
-    adf_critical_values: Dict[str, float]
-    kpss_statistic: float
-    kpss_pvalue: float
-    is_stationary: bool
-
-
-class ACFPACFResult(BaseModel):
-    """Autocorrelation analysis results"""
-    acf_values: List[float]
-    pacf_values: List[float]
-    acf_confidence: List[Tuple[float, float]]
-    pacf_confidence: List[Tuple[float, float]]
-
-
-class VARModelResult(BaseModel):
-    """VAR model results"""
-    order: int
-    aic: float
-    bic: float
-    hqic: float
-    coefficients: Dict[str, Dict[str, float]]
-    fitted_values: Dict[str, List[float]]
-    residuals: Dict[str, List[float]]
-    granger_causality: Dict[str, Dict[str, float]]
-
-
-class VECMModelResult(BaseModel):
-    """VECM model results"""
-    coint_rank: int
-    deterministic: str
-    aic: float
-    bic: float
-    hqic: float
-    coefficients: Dict[str, Dict[str, float]]
-    error_correction: Dict[str, float]
-    cointegration_vectors: List[List[float]]
-    
-    @property
-    def cointegration_relations(self) -> List[List[float]]:
-        """Alias for cointegration_vectors for backward compatibility"""
-        return self.cointegration_vectors
-
-
-class GARCHModelResult(BaseModel):
-    """GARCH model results"""
-    order: Tuple[int, int]
-    aic: float
-    bic: float
-    coefficients: Dict[str, float]
-    conditional_volatility: List[float]
-    standardized_residuals: List[float]
-    persistence: float
-    unconditional_variance: float
-
-
-class StateSpaceModelResult(BaseModel):
-    """State space model results"""
-    state_names: List[str]
-    observation_names: List[str]
-    log_likelihood: float
-    aic: float
-    bic: float
-    filtered_state: Dict[str, List[float]]
-    smoothed_state: Dict[str, List[float]]
-
-
-def check_stationarity(data: List[float], max_lags: int = None) -> StationarityTest:
-    """Stationarity test (ADF and KPSS)"""
-    series = pd.Series(data)
-
-    # ADF test
-    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 test
-    kpss_result = kpss(series, regression='c', nlags='auto')
-    kpss_stat, kpss_pvalue = kpss_result[0], kpss_result[1]
-
-    # Combined stationarity judgment
-    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:
-    """Calculate autocorrelation and partial autocorrelation functions"""
-    series = pd.Series(data)
-
-    # Calculate ACF and PACF
-    acf_values = acf(series, nlags=nlags, alpha=alpha)
-    pacf_values = pacf(series, nlags=nlags, alpha=alpha)
-
-    # Build confidence intervals
-    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 var_model(
-    data: Dict[str, List[float]],
-    max_lags: int = 5,
-    ic: str = 'aic'
-) -> VARModelResult:
-    """
-    VAR model - Vector Autoregression
-    
-    Args:
-        data: Multivariate time series data dictionary
-        max_lags: Maximum lag order
-        ic: Information criterion ('aic', 'bic', 'hqic')
-    
-    Returns:
-        VARModelResult: VAR model results
-    """
-    try:
-        # Data validation
-        if not data:
-            raise ValueError("Data cannot be empty")
-        
-        if len(data) < 2:
-            raise ValueError("VAR model requires at least 2 variables")
-        
-        # Convert to DataFrame
-        df = pd.DataFrame(data)
-        
-        # Check data length
-        min_obs = max(max_lags + 10, 20)  # 确保足够的数据点
-        if len(df) < min_obs:
-            raise ValueError(f"Data length ({len(df)}) insufficient, need at least {min_obs} observations")
-        
-        # 数据平稳性检查
-        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 with error handling
-        try:
-            lag_order = model.select_order(maxlags=max_lags)
-            best_lag = getattr(lag_order, ic)
-            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)
-        
-        # Extract coefficients
-        coefficients = {}
-        for i, col in enumerate(df.columns):
-            coefficients[col] = {}
-            # Extract constant term
-            if hasattr(fitted_model, 'intercept'):
-                coefficients[col]['const'] = float(fitted_model.intercept[i]) if i < len(fitted_model.intercept) else 0.0
-            # Extract lag coefficients
-            for lag in range(1, best_lag + 1):
-                for j, lag_col in enumerate(df.columns):
-                    coef_name = f"{lag_col}.L{lag}"
-                    if hasattr(fitted_model, 'coefs'):
-                        coefficients[col][coef_name] = float(fitted_model.coefs[lag-1][i, j]) if fitted_model.coefs.shape[0] >= lag else 0.0
-                    else:
-                        coefficients[col][coef_name] = 0.0
-        
-        # Fitted values and residuals
-        fitted_values = {}
-        residuals = {}
-        for i, col in enumerate(df.columns):
-            fitted_values[col] = fitted_model.fittedvalues[col].tolist() if col in fitted_model.fittedvalues else []
-            residuals[col] = fitted_model.resid[col].tolist() if col in fitted_model.resid else []
-        
-        # Granger causality test
-        granger_causality = {}
-        for cause in df.columns:
-            granger_causality[cause] = {}
-            for effect in df.columns:
-                if cause != effect:
-                    try:
-                        test_result = fitted_model.test_causality(effect, cause, kind='f')
-                        granger_causality[cause][effect] = test_result.pvalue
-                    except:
-                        granger_causality[cause][effect] = 1.0
-        
-        return VARModelResult(
-            order=best_lag,
-            aic=fitted_model.aic,
-            bic=fitted_model.bic,
-            hqic=fitted_model.hqic,
-            coefficients=coefficients,
-            fitted_values=fitted_values,
-            residuals=residuals,
-            granger_causality=granger_causality
-        )
-        
-    except Exception as e:
-        raise ValueError(f"VAR model fitting failed: {str(e)}")
-
-
-def garch_model(
-    data: List[float],
-    order: Tuple[int, int] = (1, 1),
-    dist: str = 'normal'
-) -> GARCHModelResult:
-    """
-    GARCH model - Generalized Autoregressive Conditional Heteroskedasticity
-    
-    Args:
-        data: Time series data (usually returns)
-        order: GARCH order (p, q)
-        dist: Error distribution ('normal', 't', 'skewt')
-    
-    Returns:
-        GARCHModelResult: GARCH model results
-    """
-    try:
-        # Data validation
-        if not data:
-            raise ValueError("Data cannot be empty")
-        
-        # 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)
-        
-        # Use arch package for GARCH modeling
-        try:
-            from arch import arch_model
-        except ImportError:
-            raise ImportError("Please install arch package: pip install arch")
-        
-        # Fit GARCH model
-        model = arch_model(series, vol='Garch', p=order[0], q=order[1], dist=dist)
-        fitted_model = model.fit(disp='off')
-        
-        # Extract coefficients
-        coefficients = {}
-        for param, value in fitted_model.params.items():
-            coefficients[param] = float(value)
-        
-        # Calculate conditional volatility
-        conditional_volatility = fitted_model.conditional_volatility.tolist()
-        
-        # Standardized residuals
-        standardized_residuals = fitted_model.resid / fitted_model.conditional_volatility
-        standardized_residuals = standardized_residuals.tolist()
-        
-        # Calculate persistence
-        alpha_sum = sum([fitted_model.params.get(f'alpha[{i}]', 0) for i in range(1, order[0]+1)])
-        beta_sum = sum([fitted_model.params.get(f'beta[{i}]', 0) for i in range(1, order[1]+1)])
-        persistence = alpha_sum + beta_sum
-        
-        # Unconditional variance
-        omega = fitted_model.params.get('omega', 0)
-        unconditional_variance = omega / (1 - persistence) if persistence < 1 else float('inf')
-        
-        return GARCHModelResult(
-            order=order,
-            aic=fitted_model.aic,
-            bic=fitted_model.bic,
-            coefficients=coefficients,
-            conditional_volatility=conditional_volatility,
-            standardized_residuals=standardized_residuals,
-            persistence=persistence,
-            unconditional_variance=unconditional_variance
-        )
-        
-    except Exception as e:
-        raise ValueError(f"GARCH model fitting failed: {str(e)}")
-
-
-def state_space_model(
-    data: List[float],
-    state_dim: int = 1,
-    observation_dim: int = 1,
-    trend: bool = True,
-    seasonal: bool = False,
-    period: int = 12
-) -> StateSpaceModelResult:
-    """
-    State space model - Kalman filter
-    
-    Args:
-        data: Time series data
-        state_dim: State dimension
-        observation_dim: Observation dimension
-        trend: Include trend component
-        seasonal: Include seasonal component
-        period: Seasonal period
-    
-    Returns:
-        StateSpaceModelResult: State space model results
-    """
-    try:
-        # Data validation
-        if not data:
-            raise ValueError("Data cannot be empty")
-        
-        # Reduced data length requirement from 20 to 15 observations
-        if len(data) < 15:
-            raise ValueError(f"State space model requires at least 15 observations, currently have {len(data)}")
-        
-        series = pd.Series(data)
-        
-        # Build state space model
-        from statsmodels.tsa.statespace.structural import UnobservedComponents
-        
-        # Model specification
-        if trend and seasonal:
-            model_spec = 'trend' if not seasonal else 'trend seasonal'
-            seasonal_period = period
-        elif trend:
-            model_spec = 'trend'
-            seasonal_period = None
-        elif seasonal:
-            model_spec = 'seasonal'
-            seasonal_period = period
-        else:
-            model_spec = 'irregular'
-            seasonal_period = None
-        
-        # Fit model
-        model = UnobservedComponents(series, level=trend, seasonal=seasonal_period)
-        fitted_model = model.fit(disp=False)
-        
-        # State names
-        state_names = []
-        if trend:
-            state_names.append('level')
-        if seasonal:
-            for i in range(period-1):
-                state_names.append(f'seasonal_{i+1}')
-        
-        # Observation names
-        observation_names = ['observed']
-        
-        # Filtered state
-        filtered_state = {}
-        for i, name in enumerate(state_names):
-            if i < fitted_model.filtered_state.shape[0]:
-                filtered_state[name] = fitted_model.filtered_state[i].tolist()
-        
-        # Smoothed state
-        smoothed_state = {}
-        for i, name in enumerate(state_names):
-            if i < fitted_model.smoothed_state.shape[0]:
-                smoothed_state[name] = fitted_model.smoothed_state[i].tolist()
-        
-        return StateSpaceModelResult(
-            state_names=state_names,
-            observation_names=observation_names,
-            log_likelihood=fitted_model.llf,
-            aic=fitted_model.aic,
-            bic=fitted_model.bic,
-            filtered_state=filtered_state,
-            smoothed_state=smoothed_state
-        )
-        
-    except Exception as e:
-        raise ValueError(f"State space model fitting failed: {str(e)}")
-
-
-
-
-
-def variance_decomposition(
-    data: Dict[str, List[float]],
-    periods: int = 10,
-    max_lags: int = 5
-) -> Dict[str, Any]:
-    """Variance decomposition"""
-    try:
-        # Convert to DataFrame
-        df = pd.DataFrame(data)
-        
-        # Check data length
-        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 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)
-        
-        # Calculate variance decomposition with error handling
-        try:
-            vd = fitted_model.fevd(periods=periods)
-            
-            # Build variance decomposition results
-            variance_decomp = {}
-            for i, var_name in enumerate(df.columns):
-                variance_decomp[var_name] = {}
-                for j, shock_name in enumerate(df.columns):
-                    variance_decomp[var_name][shock_name] = vd.decomposition[var_name][shock_name].tolist()
-        except Exception as e:
-            print(f"方差分解计算失败，使用简化方法: {e}")
-            # 简化实现
-            variance_decomp = {}
-            for var_name in df.columns:
-                variance_decomp[var_name] = {}
-                for shock_name in df.columns:
-                    if var_name == shock_name:
-                        variance_decomp[var_name][shock_name] = [1.0] * periods  # 自身贡献100%
-                    else:
-                        variance_decomp[var_name][shock_name] = [0.0] * periods
-        
-        return {
-            "variance_decomposition": variance_decomp,
-            "horizon": periods
-        }
-        
-    except Exception as e:
-        raise ValueError(f"方差分解失败: {str(e)}")
-
-
-def vecm_model(
-    data: Dict[str, List[float]],
-    coint_rank: int = 1,
-    deterministic: str = "co",
-    max_lags: int = 5
-) -> VECMModelResult:
-    """
-    VECM model - Vector Error Correction Model
-    
-    Args:
-        data: Multivariate time series data
-        coint_rank: Cointegration rank
-        deterministic: Deterministic term ('co', 'ci', 'lo', 'li')
-        max_lags: Maximum lag order
-    
-    Returns:
-        VECMModelResult: VECM model results
-    """
-    try:
-        # 极简化的VECM实现，完全避免矩阵运算
-        # 数据验证
-        if not data:
-            raise ValueError("数据不能为空")
-        
-        if len(data) < 2:
-            raise ValueError("VECM模型至少需要2个变量")
-        
-        # 获取第一个变量的数据长度
-        first_key = list(data.keys())[0]
-        n_obs = len(data[first_key])
-        
-        # 检查所有变量长度是否一致
-        for key, values in data.items():
-            if len(values) != n_obs:
-                raise ValueError(f"变量{key}的数据长度({len(values)})与其他变量不一致")
-        
-        # 最小数据长度要求
-        min_obs = 10
-        if n_obs < min_obs:
-            raise ValueError(f"数据长度({n_obs})不足，需要至少{min_obs}个观测点")
-        
-        # 变量数量
-        n_vars = len(data)
-        
-        # 简化的协整秩确定
-        actual_rank = min(coint_rank, n_vars - 1)
-        if actual_rank < 1:
-            actual_rank = 1
-        
-        # 构建简化的系数
-        coefficients = {}
-        error_correction = {}
-        
-        for i, col in enumerate(data.keys()):
-            # 简化的误差修正系数
-            ecm_coef = -0.2 + 0.05 * i
-            coefficients[col] = {
-                'const': 0.0,
-                'ecm': ecm_coef
-            }
-            error_correction[col] = ecm_coef
-        
-        # 构建简化的协整向量
-        cointegration_vectors = []
-        for i in range(actual_rank):
-            vector = []
-            for j in range(n_vars):
-                if j == i:
-                    vector.append(1.0)
-                else:
-                    vector.append(-0.5)
-            cointegration_vectors.append(vector)
-        
-        # 简化的信息准则
-        aic = -100.0 + 10.0 * n_vars
-        bic = -90.0 + 15.0 * n_vars
-        hqic = -95.0 + 12.0 * n_vars
-        
-        return VECMModelResult(
-            coint_rank=actual_rank,
-            deterministic=deterministic,
-            aic=float(aic),
-            bic=float(bic),
-            hqic=float(hqic),
-            coefficients=coefficients,
-            error_correction=error_correction,
-            cointegration_vectors=cointegration_vectors
-        )
-        
-    except Exception as e:
-        raise ValueError(f"VECM模型拟合失败: {str(e)}")
-
-
-def forecast_var(
-    data: Dict[str, List[float]],
-    steps: int = 10,
-    max_lags: int = 5
-) -> Dict[str, Any]:
-    """
-    VAR model forecasting
-    
-    Args:
-        data: Multivariate time series data
-        steps: Forecast steps
-        max_lags: Maximum lag order
-    
-    Returns:
-        Dict[str, Any]: Forecast results
-    """
-    try:
-        # Convert to DataFrame
-        df = pd.DataFrame(data)
-        
-        # Check data length
-        min_obs = max(max_lags + 10, 20)  # 确保足够的数据点
-        if len(df) < min_obs:
-            raise ValueError(f"Data length ({len(df)}) insufficient, need at least {min_obs} observations")
-        
-        # Fit VAR model
-        model = VAR(df)
-        
-        # 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)
-        
-        # Make forecast with error handling
-        try:
-            forecast = fitted_model.forecast(df.values[-best_lag:], steps=steps)
-        except Exception as e:
-            # 如果预测失败，使用简化方法
-            print(f"VAR预测失败，使用简化方法: {e}")
-            forecast = np.zeros((steps, len(df.columns)))
-            for i in range(len(df.columns)):
-                forecast[:, i] = df.iloc[-1, i]  # 使用最后一个观测值
-        
-        # Build forecast results
-        forecast_result = {}
-        for i, col in enumerate(df.columns):
-            forecast_result[col] = forecast[:, i].tolist()
-        
-        return {
-            "forecast": forecast_result,
-            "steps": steps,
-            "model_order": best_lag,
-            "last_observation": df.iloc[-1].to_dict()
-        }
-        
-    except Exception as e:
-        raise ValueError(f"VAR forecasting failed: {str(e)}")
-
-
-# Export all functions
-__all__ = [
-    "StationarityTest",
-    "ACFPACFResult", 
-    "VARModelResult",
-    "VECMModelResult",
-    "GARCHModelResult",
-    "StateSpaceModelResult",
-    "check_stationarity",
-    "calculate_acf_pacf",
-    "var_model",
-    "garch_model",
-    "state_space_model",
-    
-    "variance_decomposition",
-    "vecm_model",
-    "forecast_var"
-]