aigroup-econ-mcp 1.3.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

econometrics/basic_parametric_estimation/gmm/gmm_model.py

@@ -0,0 +1,256 @@
+"""
+广义矩估计 (GMM) 模型实现
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import numpy as np
+from scipy import stats
+
+
+class GMMResult(BaseModel):
+    """广义矩估计结果"""
+    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="置信区间上界")
+    j_statistic: float = Field(..., description="J统计量")
+    j_p_value: float = Field(..., description="J统计量p值")
+    weight_matrix: List[List[float]] = Field(..., description="权重矩阵")
+    n_obs: int = Field(..., description="观测数量")
+    n_moments: int = Field(..., description="矩条件数量")
+    feature_names: List[str] = Field(..., description="特征名称")
+
+
+def _safe_inverse(matrix, reg_param=1e-10):
+    """安全的矩阵求逆函数"""
+    try:
+        # 检查矩阵是否为空或非二维
+        if matrix.size == 0 or matrix.ndim != 2:
+            raise ValueError("矩阵为空或不是二维数组")
+        
+        # 检查矩阵是否包含无效值
+        if np.isnan(matrix).any() or np.isinf(matrix).any():
+            raise ValueError("矩阵包含NaN或无穷大值")
+            
+        # 尝试直接求逆
+        return np.linalg.inv(matrix)
+    except np.linalg.LinAlgError:
+        # 如果矩阵奇异，添加正则化项
+        try:
+            # 确保矩阵是方阵
+            if matrix.shape[0] != matrix.shape[1]:
+                raise ValueError("矩阵不是方阵，无法求逆")
+                
+            # 添加正则化项
+            reg_matrix = matrix + np.eye(matrix.shape[0]) * reg_param
+            return np.linalg.inv(reg_matrix)
+        except np.linalg.LinAlgError:
+            # 如果仍然失败，使用伪逆
+            return np.linalg.pinv(matrix)
+
+
+def gmm_estimation(
+    y_data: List[float],
+    x_data: List[List[float]], 
+    instruments: Optional[List[List[float]]] = None,
+    feature_names: Optional[List[str]] = None,
+    constant: bool = True,
+    confidence_level: float = 0.95
+) -> GMMResult:
+    """
+    广义矩估计
+    
+    Args:
+        y_data: 因变量数据
+        x_data: 自变量数据
+        instruments: 工具变量数据 (如果为None，则使用x_data作为工具变量，退化为OLS)
+        feature_names: 特征名称
+        constant: 是否包含常数项
+        confidence_level: 置信水平
+        
+    Returns:
+        GMMResult: 广义矩估计结果
+        
+    Raises:
+        ValueError: 当输入数据无效时抛出异常
+    """
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("因变量和自变量数据不能为空")
+    
+    # 转换为numpy数组
+    y = np.array(y_data)
+    
+    # 确保X是二维数组
+    if isinstance(x_data[0], (int, float)):
+        # 单个特征的情况
+        X = np.array(x_data).reshape(-1, 1)
+    else:
+        X = np.array(x_data)
+    
+    # 验证数据维度一致性
+    if len(y) != X.shape[0]:
+        raise ValueError(f"因变量长度({len(y)})与自变量长度({X.shape[0]})不一致")
+    
+    n, k = X.shape
+    
+    # 处理工具变量
+    if instruments is None:
+        # 如果没有提供工具变量，则使用自变量作为工具变量（退化为OLS）
+        Z = X.copy()
+    else:
+        # 确保工具变量是二维数组
+        if isinstance(instruments[0], (int, float)):
+            Z = np.array(instruments).reshape(-1, 1)
+        else:
+            Z = np.array(instruments)
+        
+        # 验证工具变量维度
+        if len(Z) != len(y):
+            raise ValueError(f"工具变量长度({len(Z)})与因变量长度({len(y)})不一致")
+    
+    # 添加常数项
+    if constant:
+        X = np.column_stack([np.ones(n), X])
+        Z = np.column_stack([np.ones(n), Z])
+        if feature_names:
+            feature_names = ["const"] + feature_names
+        else:
+            feature_names = [f"const"] + [f"x{i}" for i in range(X.shape[1]-1)]
+    else:
+        if not feature_names:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    
+    # 手动实现GMM估计
+    try:
+        # 初始化权重矩阵为单位矩阵
+        W = np.eye(Z.shape[1])
+        
+        # 迭代估计直到收敛
+        for iteration in range(100):  # 最大迭代次数
+            # 一步GMM估计
+            # X'Z W Z'X beta = X'Z W Z'y
+            XZ = X.T @ Z
+            ZY = Z.T @ y
+            
+            # 更稳定的矩阵运算
+            left_side = XZ @ W @ XZ.T
+            right_side = XZ @ W @ ZY
+            
+            # 解线性方程组
+            try:
+                beta = np.linalg.solve(left_side, right_side)
+            except np.linalg.LinAlgError:
+                # 如果矩阵奇异，使用伪逆
+                beta = np.linalg.pinv(left_side) @ right_side
+            
+            # 计算残差
+            residuals = y - X @ beta
+            
+            # 更新权重矩阵（基于残差的矩条件）
+            moments = Z * residuals.reshape(-1, 1)
+            S = moments.T @ moments / n  # 协方差矩阵
+            
+            # 在更新权重矩阵前进行有效性检查
+            if np.isnan(S).any() or np.isinf(S).any():
+                raise ValueError("矩条件协方差矩阵包含无效值")
+            
+            # 安全地更新权重矩阵
+            W_new = _safe_inverse(S, reg_param=1e-8)  # 增加正则化参数以提高稳定性
+            
+            # 检查新权重矩阵的有效性
+            if np.isnan(W_new).any() or np.isinf(W_new).any():
+                raise ValueError("计算出的权重矩阵包含无效值")
+                
+            # 检查收敛性
+            if np.allclose(W, W_new, rtol=1e-6, atol=1e-10):
+                W = W_new
+                break
+            W = W_new
+        
+        # 计算最终的协方差矩阵和统计量
+        residuals = y - X @ beta
+        moments = Z * residuals.reshape(-1, 1)
+        S = moments.T @ moments / n
+        
+        # 检查矩条件协方差矩阵
+        if np.isnan(S).any() or np.isinf(S).any() or np.linalg.norm(S) == 0:
+            raise ValueError("矩条件协方差矩阵无效")
+        
+        # 计算系数协方差矩阵
+        # Var(beta) = (X'Z W Z'X)^(-1) X'Z W S W Z'X (X'Z W Z'X)^(-1)
+        XZ = X.T @ Z
+        
+        # 检查XZ矩阵
+        if np.isnan(XZ).any() or np.isinf(XZ).any():
+            raise ValueError("X'Z矩阵包含无效值")
+            
+        left_side = XZ @ W @ XZ.T
+        
+        # 检查左侧矩阵
+        if np.isnan(left_side).any() or np.isinf(left_side).any():
+            raise ValueError("左侧矩阵(X'Z W Z'X)包含无效值")
+        
+        left_side_inv = _safe_inverse(left_side, reg_param=1e-8)  # 使用相同正则化参数
+        
+        # 检查逆矩阵
+        if np.isnan(left_side_inv).any() or np.isinf(left_side_inv).any():
+            raise ValueError("左侧矩阵的逆包含无效值")
+        
+        # 计算协方差矩阵
+        cov_intermediate = XZ @ W @ S @ W @ XZ.T
+        if np.isnan(cov_intermediate).any() or np.isinf(cov_intermediate).any():
+            raise ValueError("中间协方差计算包含无效值")
+            
+        cov_beta = left_side_inv @ cov_intermediate @ left_side_inv
+        std_errors = np.sqrt(np.diag(cov_beta))
+        
+        # 避免零标准误
+        std_errors = np.maximum(std_errors, 1e-12)
+        
+        # 检查标准误
+        if np.isnan(std_errors).any() or np.isinf(std_errors).any():
+            raise ValueError("计算出的标准误包含无效值")
+        
+        # 计算t统计量和p值
+        t_values = beta / std_errors
+        p_values = 2 * (1 - stats.t.cdf(np.abs(t_values), n - len(beta)))
+        
+        # 计算置信区间
+        alpha = 1 - confidence_level
+        t_critical = stats.t.ppf(1 - alpha/2, n - len(beta))
+        conf_int_lower = beta - t_critical * std_errors
+        conf_int_upper = beta + t_critical * std_errors
+        
+        # J统计量（过度识别约束检验）
+        if Z.shape[1] > len(beta):
+            # 过度识别情况
+            moment_conditions = Z.T @ residuals
+            j_statistic = n * moment_conditions.T @ W @ moment_conditions
+            j_df = Z.shape[1] - len(beta)
+            j_p_value = 1 - stats.chi2.cdf(j_statistic, j_df)
+        else:
+            # 恰好识别情况
+            j_statistic = 0.0
+            j_p_value = 1.0
+        
+        return GMMResult(
+            coefficients=beta.tolist(),
+            std_errors=std_errors.tolist(),
+            t_values=t_values.tolist(),
+            p_values=p_values.tolist(),
+            conf_int_lower=conf_int_lower.tolist(),
+            conf_int_upper=conf_int_upper.tolist(),
+            j_statistic=float(j_statistic),
+            j_p_value=float(j_p_value),
+            weight_matrix=W.tolist(),
+            n_obs=n,
+            n_moments=Z.shape[1],
+            feature_names=feature_names
+        )
+    except Exception as e:
+        # 如果GMM失败，抛出异常
+        raise ValueError(f"GMM估计失败: {str(e)}")

econometrics/basic_parametric_estimation/mle/__init__.py

@@ -0,0 +1,13 @@
+"""
+最大似然估计 (MLE) 模块
+"""
+
+from .mle_model import (
+    MLEResult,
+    mle_estimation
+)
+
+__all__ = [
+    "MLEResult",
+    "mle_estimation"
+]

econometrics/basic_parametric_estimation/mle/mle_model.py

@@ -0,0 +1,241 @@
+"""
+最大似然估计 (MLE) 模型实现
+"""
+
+from typing import List, Dict, Any, Optional, Callable
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+import numpy as np
+import pandas as pd
+from scipy.optimize import minimize
+from scipy import stats
+import statsmodels.api as sm
+from statsmodels.base.model import GenericLikelihoodModel
+
+
+class MLEResult(BaseModel):
+    """最大似然估计结果"""
+    parameters: List[float] = Field(..., description="估计参数")
+    std_errors: List[float] = Field(..., description="参数标准误")
+    conf_int_lower: List[float] = Field(..., description="置信区间下界")
+    conf_int_upper: List[float] = Field(..., description="置信区间上界")
+    log_likelihood: float = Field(..., description="对数似然值")
+    aic: float = Field(..., description="赤池信息准则")
+    bic: float = Field(..., description="贝叶斯信息准则")
+    convergence: bool = Field(..., description="是否收敛")
+    n_obs: int = Field(..., description="观测数量")
+    param_names: List[str] = Field(..., description="参数名称")
+
+
+def mle_estimation(
+    data: List[float],
+    distribution: str = "normal",
+    initial_params: Optional[List[float]] = None,
+    confidence_level: float = 0.95
+) -> MLEResult:
+    """
+    最大似然估计
+    
+    Args:
+        data: 数据
+        distribution: 分布类型 ('normal', 'poisson', 'exponential')
+        initial_params: 初始参数值
+        confidence_level: 置信水平
+        
+    Returns:
+        MLEResult: 最大似然估计结果
+        
+    Raises:
+        ValueError: 当输入数据无效时抛出异常
+    """
+    # 输入验证
+    if not data:
+        raise ValueError("数据不能为空")
+    
+    data = np.array(data, dtype=np.float64)
+    n = len(data)
+    
+    # 检查数据有效性
+    if np.isnan(data).any():
+        raise ValueError("数据中包含缺失值(NaN)")
+    
+    if np.isinf(data).any():
+        raise ValueError("数据中包含无穷大值")
+    
+    # 分布特定的验证
+    if distribution == "exponential" and np.any(data < 0):
+        raise ValueError("指数分布的数据必须为非负数")
+    
+    if distribution == "poisson" and (np.any(data < 0) or not np.all(data == np.floor(data))):
+        raise ValueError("泊松分布的数据必须为非负整数")
+    
+    if distribution == "normal":
+        # 正态分布的MLE
+        return _normal_mle(data, initial_params, confidence_level)
+    elif distribution == "poisson":
+        # 泊松分布的MLE
+        return _poisson_mle(data, initial_params, confidence_level)
+    elif distribution == "exponential":
+        # 指数分布的MLE
+        return _exponential_mle(data, initial_params, confidence_level)
+    else:
+        raise ValueError(f"不支持的分布类型: {distribution}")
+
+
+def _normal_mle(data: np.ndarray, initial_params: Optional[List[float]], confidence_level: float) -> MLEResult:
+    """正态分布最大似然估计"""
+    # 使用样本均值和标准差作为初始估计
+    mu_hat = np.mean(data)
+    sigma_hat = np.std(data, ddof=1)  # 使用样本标准差
+    
+    # 检查标准差是否为零
+    if sigma_hat == 0:
+        raise ValueError("数据标准差为零，无法进行正态分布MLE估计")
+    
+    # 使用statsmodels的MLE估计
+    try:
+        # 直接使用解析解
+        n = len(data)
+        log_likelihood = float(np.sum(stats.norm.logpdf(data, loc=mu_hat, scale=sigma_hat)))
+        
+        # 标准误
+        std_error_mu = sigma_hat / np.sqrt(n)
+        std_error_sigma = sigma_hat / np.sqrt(2 * n)
+        std_errors = [std_error_mu, std_error_sigma]
+        
+        # 置信区间
+        alpha = 1 - confidence_level
+        z_value = stats.norm.ppf(1 - alpha/2)
+        conf_int_lower = [mu_hat - z_value * std_error_mu, sigma_hat - z_value * std_error_sigma]
+        conf_int_upper = [mu_hat + z_value * std_error_mu, sigma_hat + z_value * std_error_sigma]
+        
+        # 信息准则
+        k = 2  # 参数数量
+        aic = -2 * log_likelihood + 2 * k
+        bic = -2 * log_likelihood + k * np.log(n)
+        
+        return MLEResult(
+            parameters=[float(mu_hat), float(sigma_hat)],
+            std_errors=std_errors,
+            conf_int_lower=conf_int_lower,
+            conf_int_upper=conf_int_upper,
+            log_likelihood=log_likelihood,
+            aic=float(aic),
+            bic=float(bic),
+            convergence=True,
+            n_obs=n,
+            param_names=["mu", "sigma"]
+        )
+    except Exception as e:
+        raise ValueError(f"正态分布MLE估计失败: {str(e)}")
+
+
+def _poisson_mle(data: np.ndarray, initial_params: Optional[List[float]], confidence_level: float) -> MLEResult:
+    """泊松分布最大似然估计"""
+    # 泊松分布的MLE有解析解：lambda_hat = mean(data)
+    lambda_hat = np.mean(data)
+    n = len(data)
+    
+    # 检查均值是否为零
+    if lambda_hat == 0:
+        raise ValueError("数据均值为零，无法进行泊松分布MLE估计")
+    
+    try:
+        # 计算对数似然值
+        log_likelihood = float(np.sum(stats.poisson.logpmf(data, lambda_hat)))
+        
+        # 标准误
+        std_error = np.sqrt(lambda_hat / n)
+        std_errors = [std_error]
+        
+        # 置信区间
+        alpha = 1 - confidence_level
+        z_value = stats.norm.ppf(1 - alpha/2)
+        conf_int_lower = [lambda_hat - z_value * std_error]
+        conf_int_upper = [lambda_hat + z_value * std_error]
+        
+        # 信息准则
+        k = 1  # 参数数量
+        aic = -2 * log_likelihood + 2 * k
+        bic = -2 * log_likelihood + k * np.log(n)
+        
+        return MLEResult(
+            parameters=[float(lambda_hat)],
+            std_errors=std_errors,
+            conf_int_lower=conf_int_lower,
+            conf_int_upper=conf_int_upper,
+            log_likelihood=log_likelihood,
+            aic=float(aic),
+            bic=float(bic),
+            convergence=True,
+            n_obs=n,
+            param_names=["lambda"]
+        )
+    except Exception as e:
+        raise ValueError(f"泊松分布MLE估计失败: {str(e)}")
+
+
+def _exponential_mle(data: np.ndarray, initial_params: Optional[List[float]], confidence_level: float) -> MLEResult:
+    """指数分布最大似然估计"""
+    # 指数分布的MLE有解析解：lambda_hat = 1 / mean(data)
+    mean_data = np.mean(data)
+    if mean_data <= 0:
+        raise ValueError("指数分布的数据均值必须为正数")
+    
+    lambda_hat = 1.0 / mean_data
+    n = len(data)
+    
+    # 检查参数有效性
+    if not np.isfinite(lambda_hat):
+        raise ValueError("计算出的参数值无效")
+    
+    try:
+        # 计算对数似然值
+        log_likelihood = float(np.sum(stats.expon.logpdf(data, scale=1/lambda_hat)))
+        
+        # 标准误计算 (对于指数分布，标准误为lambda/sqrt(n))
+        # 使用更精确的计算方法
+        std_error = lambda_hat / np.sqrt(n)
+        std_errors = [std_error]
+        
+        # 验证标准误的有效性
+        if not np.isfinite(std_error) or std_error <= 0:
+            raise ValueError("计算出的标准误无效")
+        
+        # 置信区间
+        alpha = 1 - confidence_level
+        z_value = stats.norm.ppf(1 - alpha/2)
+        
+        # 检查z值有效性
+        if not np.isfinite(z_value):
+            raise ValueError("计算出的临界值无效")
+            
+        conf_int_lower = [lambda_hat - z_value * std_error]
+        conf_int_upper = [lambda_hat + z_value * std_error]
+        
+        # 检查置信区间边界有效性
+        if not (np.isfinite(conf_int_lower[0]) and np.isfinite(conf_int_upper[0])):
+            raise ValueError("计算出的置信区间无效")
+            
+        # 确保置信区间下限不为负
+        conf_int_lower[0] = max(conf_int_lower[0], 1e-10)
+        
+        # 信息准则
+        k = 1  # 参数数量
+        aic = -2 * log_likelihood + 2 * k
+        bic = -2 * log_likelihood + k * np.log(n)
+        
+        return MLEResult(
+            parameters=[float(lambda_hat)],
+            std_errors=std_errors,
+            conf_int_lower=conf_int_lower,
+            conf_int_upper=conf_int_upper,
+            log_likelihood=log_likelihood,
+            aic=float(aic),
+            bic=float(bic),
+            convergence=True,
+            n_obs=n,
+            param_names=["lambda"]
+        )
+    except Exception as e:
+        raise ValueError(f"指数分布MLE估计失败: {str(e)}")

econometrics/basic_parametric_estimation/ols/__init__.py

@@ -0,0 +1,13 @@
+"""
+普通最小二乘法 (OLS) 模块
+"""
+
+from .ols_model import (
+    OLSResult,
+    ols_regression
+)
+
+__all__ = [
+    "OLSResult",
+    "ols_regression"
+]

econometrics/basic_parametric_estimation/ols/ols_model.py

@@ -0,0 +1,141 @@
+"""
+普通最小二乘法 (OLS) 模型实现
+"""
+
+from typing import List, Dict, Any, Optional, Union
+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
+
+
+class OLSResult(BaseModel):
+    """OLS回归结果"""
+    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值")
+    aic: float = Field(..., description="赤池信息准则")
+    bic: float = Field(..., description="贝叶斯信息准则")
+    n_obs: int = Field(..., description="观测数量")
+    feature_names: List[str] = Field(..., description="特征名称")
+
+
+def ols_regression(
+    y_data: List[float],
+    x_data: List[List[float]], 
+    feature_names: Optional[List[str]] = None,
+    constant: bool = True,
+    confidence_level: float = 0.95
+) -> OLSResult:
+    """
+    普通最小二乘法回归
+    
+    Args:
+        y_data: 因变量数据
+        x_data: 自变量数据
+        feature_names: 特征名称
+        constant: 是否包含常数项
+        confidence_level: 置信水平
+        
+    Returns:
+        OLSResult: OLS回归结果
+        
+    Raises:
+        ValueError: 当输入数据无效时抛出异常
+    """
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("因变量和自变量数据不能为空")
+    
+    # 转换为numpy数组
+    y = np.array(y_data, dtype=np.float64)
+    
+    # 确保X是二维数组
+    if x_data and isinstance(x_data[0], (int, float)):
+        # 单个特征的情况，需要转置
+        X = np.array(x_data, dtype=np.float64).reshape(-1, 1)
+    else:
+        X = np.array(x_data, dtype=np.float64)
+    
+    # 验证数据维度一致性
+    if len(y) != X.shape[0]:
+        raise ValueError(f"因变量长度({len(y)})与自变量长度({X.shape[0]})不一致")
+    
+    # 检查是否有足够的数据点
+    if len(y) < X.shape[1] + (1 if constant else 0):
+        raise ValueError("数据点数量不足以估计模型参数")
+    
+    # 检查是否存在缺失值或无穷大值
+    if np.isnan(y).any() or np.isnan(X).any():
+        raise ValueError("数据中包含缺失值(NaN)")
+    
+    if np.isinf(y).any() or np.isinf(X).any():
+        raise ValueError("数据中包含无穷大值")
+    
+    # 添加常数项
+    if constant:
+        X = sm.add_constant(X)
+        if feature_names:
+            feature_names = ["const"] + feature_names
+        else:
+            feature_names = ["const"] + [f"x{i}" for i in range(X.shape[1]-1)]
+    else:
+        if not feature_names:
+            feature_names = [f"x{i}" for i in range(X.shape[1])]
+    
+    # 使用statsmodels执行OLS回归
+    try:
+        model = sm.OLS(y, X)
+        results = model.fit()
+    except Exception as e:
+        raise ValueError(f"无法拟合OLS模型: {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
+    
+    # 信息准则
+    aic = float(results.aic)
+    bic = float(results.bic)
+    
+    return OLSResult(
+        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,
+        aic=aic,
+        bic=bic,
+        n_obs=int(results.nobs),
+        feature_names=feature_names
+    )