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

econometrics/spatial_econometrics/spatial_regression.py

@@ -0,0 +1,315 @@
+"""
+空间回归模型
+基于 spreg 库实现空间滞后模型(SAR)和空间误差模型(SEM)
+"""
+
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from spreg import OLS as Spreg_OLS
+    from spreg import ML_Lag, ML_Error, GM_Lag, GM_Error
+    from libpysal.weights import W
+    SPREG_AVAILABLE = True
+except ImportError:
+    SPREG_AVAILABLE = False
+    ML_Lag = None
+    ML_Error = None
+    GM_Lag = None
+    GM_Error = None
+    W = None
+
+
+class SpatialRegressionResult(BaseModel):
+    """空间回归模型结果"""
+    model_type: str = Field(..., description="模型类型 (SAR/SEM)")
+    method: str = Field(..., description="估计方法 (ML/GMM)")
+    coefficients: List[float] = Field(..., description="回归系数")
+    std_errors: List[float] = Field(..., description="标准误")
+    z_scores: List[float] = Field(..., description="Z统计量")
+    p_values: List[float] = Field(..., description="P值")
+    feature_names: List[str] = Field(..., description="特征名称")
+    spatial_param: float = Field(..., description="空间参数（rho或lambda）")
+    spatial_param_se: float = Field(..., description="空间参数标准误")
+    r_squared: Optional[float] = Field(None, description="伪R方")
+    log_likelihood: float = Field(..., description="对数似然值")
+    aic: float = Field(..., description="AIC信息准则")
+    schwarz: float = Field(..., description="Schwarz准则(BIC)")
+    n_observations: int = Field(..., description="观测数量")
+    summary: str = Field(..., description="摘要信息")
+
+
+def spatial_lag_model(
+    y_data: List[float],
+    x_data: List[List[float]],
+    neighbors: dict,
+    weights: Optional[dict] = None,
+    feature_names: Optional[List[str]] = None,
+    method: str = "ml"
+) -> SpatialRegressionResult:
+    """
+    空间滞后模型 (Spatial Lag Model - SAR)
+    模型形式: y = ρWy + Xβ + ε
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（二维列表）
+        neighbors: 邻居字典
+        weights: 权重字典
+        feature_names: 特征名称
+        method: 估计方法 - "ml"(最大似然) 或 "gmm"(广义矩估计)
+        
+    Returns:
+        SpatialRegressionResult: 空间滞后模型结果
+        
+    Raises:
+        ImportError: spreg库未安装
+        ValueError: 输入数据无效
+    """
+    if not SPREG_AVAILABLE:
+        raise ImportError(
+            "spreg库未安装。请运行: pip install spreg\n"
+            "或: pip install pysal"
+        )
+    
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("y_data和x_data不能为空")
+    
+    # 数据准备
+    y = np.array(y_data).reshape(-1, 1)
+    X = np.array(x_data)
+    
+    # 确保X是二维数组
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n = len(y)
+    k = X.shape[1]
+    
+    # 构建权重对象
+    if weights is None:
+        weights = {i: [1.0] * len(neighbors[i]) for i in neighbors}
+    
+    # 确保邻居字典的键是整数
+    neighbors_int = {int(k): [int(n) for n in v] for k, v in neighbors.items()}
+    weights_int = {int(k): v for k, v in weights.items()}
+    
+    w = W(neighbors_int, weights_int)
+    w.transform = 'r'  # 行标准化
+    
+    # 特征名称
+    if feature_names is None:
+        feature_names = [f"X{i+1}" for i in range(k)]
+    
+    # 估计模型
+    if method.lower() == "ml":
+        model = ML_Lag(y, X, w, name_y='y', name_x=feature_names)
+    elif method.lower() == "gmm":
+        model = GM_Lag(y, X, w, name_y='y', name_x=feature_names)
+    else:
+        raise ValueError(f"不支持的方法: {method}。支持: ml, gmm")
+    
+    # 提取结果
+    # 系数包括常数项和自变量系数
+    coefficients = model.betas.flatten().tolist()
+    
+    # 标准误、Z值、P值
+    std_errors = np.sqrt(np.diag(model.vm)).tolist()
+    
+    # 处理z_stat - 可能是列表或numpy数组
+    if hasattr(model.z_stat, 'shape'):
+        # numpy数组
+        z_scores = model.z_stat[:, 0].tolist()
+        p_values = model.z_stat[:, 1].tolist()
+    else:
+        # 列表
+        z_scores = [stat[0] for stat in model.z_stat] if model.z_stat else []
+        p_values = [stat[1] for stat in model.z_stat] if model.z_stat else []
+    
+    # 空间参数（rho）
+    # 在ML_Lag中，rho是最后一个参数
+    spatial_param = float(model.rho)
+    
+    # 尝试获取rho的标准误
+    try:
+        # rho的标准误通常在vm矩阵的最后一个对角元素
+        spatial_param_se = float(np.sqrt(model.vm[-1, -1]))
+    except:
+        spatial_param_se = 0.0
+    
+    # 伪R方（如果可用）
+    try:
+        r_squared = float(model.pr2) if hasattr(model, 'pr2') else None
+    except:
+        r_squared = None
+    
+    # 对数似然值
+    log_likelihood = float(model.logll) if hasattr(model, 'logll') else 0.0
+    
+    # 信息准则
+    aic = float(model.aic) if hasattr(model, 'aic') else 0.0
+    schwarz = float(model.schwarz) if hasattr(model, 'schwarz') else 0.0
+    
+    # 添加常数项到特征名称
+    all_feature_names = ['const'] + feature_names
+    
+    # 生成摘要
+    summary = f"""空间滞后模型 (SAR) - {method.upper()}估计:
+- 观测数量: {n}
+- 自变量数: {k}
+- 空间参数 ρ: {spatial_param:.4f} (标准误: {spatial_param_se:.4f})
+- 对数似然: {log_likelihood:.2f}
+- AIC: {aic:.2f}
+- BIC: {schwarz:.2f}
+"""
+    if r_squared is not None:
+        summary += f"- 伪R²: {r_squared:.4f}\n"
+    
+    return SpatialRegressionResult(
+        model_type="SAR",
+        method=method.upper(),
+        coefficients=coefficients,
+        std_errors=std_errors,
+        z_scores=z_scores,
+        p_values=p_values,
+        feature_names=all_feature_names,
+        spatial_param=spatial_param,
+        spatial_param_se=spatial_param_se,
+        r_squared=r_squared,
+        log_likelihood=log_likelihood,
+        aic=aic,
+        schwarz=schwarz,
+        n_observations=n,
+        summary=summary
+    )
+
+
+def spatial_error_model(
+    y_data: List[float],
+    x_data: List[List[float]],
+    neighbors: dict,
+    weights: Optional[dict] = None,
+    feature_names: Optional[List[str]] = None,
+    method: str = "ml"
+) -> SpatialRegressionResult:
+    """
+    空间误差模型 (Spatial Error Model - SEM)
+    模型形式: y = Xβ + u, u = λWu + ε
+    
+    Args:
+        y_data: 因变量
+        x_data: 自变量（二维列表）
+        neighbors: 邻居字典
+        weights: 权重字典
+        feature_names: 特征名称
+        method: 估计方法 - "ml"(最大似然) 或 "gmm"(广义矩估计)
+        
+    Returns:
+        SpatialRegressionResult: 空间误差模型结果
+    """
+    if not SPREG_AVAILABLE:
+        raise ImportError("spreg库未安装")
+    
+    # 输入验证
+    if not y_data or not x_data:
+        raise ValueError("y_data和x_data不能为空")
+    
+    # 数据准备
+    y = np.array(y_data).reshape(-1, 1)
+    X = np.array(x_data)
+    
+    if X.ndim == 1:
+        X = X.reshape(-1, 1)
+    
+    n = len(y)
+    k = X.shape[1]
+    
+    # 构建权重对象
+    if weights is None:
+        weights = {i: [1.0] * len(neighbors[i]) for i in neighbors}
+    
+    # 确保邻居字典的键是整数
+    neighbors_int = {int(k): [int(n) for n in v] for k, v in neighbors.items()}
+    weights_int = {int(k): v for k, v in weights.items()}
+    
+    w = W(neighbors_int, weights_int)
+    w.transform = 'r'
+    
+    # 特征名称
+    if feature_names is None:
+        feature_names = [f"X{i+1}" for i in range(k)]
+    
+    # 估计模型
+    if method.lower() == "ml":
+        model = ML_Error(y, X, w, name_y='y', name_x=feature_names)
+    elif method.lower() == "gmm":
+        model = GM_Error(y, X, w, name_y='y', name_x=feature_names)
+    else:
+        raise ValueError(f"不支持的方法: {method}")
+    
+    # 提取结果
+    coefficients = model.betas.flatten().tolist()
+    std_errors = np.sqrt(np.diag(model.vm)).tolist()
+    
+    # 处理z_stat - 可能是列表或numpy数组
+    if hasattr(model.z_stat, 'shape'):
+        # numpy数组
+        z_scores = model.z_stat[:, 0].tolist()
+        p_values = model.z_stat[:, 1].tolist()
+    else:
+        # 列表
+        z_scores = [stat[0] for stat in model.z_stat] if model.z_stat else []
+        p_values = [stat[1] for stat in model.z_stat] if model.z_stat else []
+    
+    # 空间参数（lambda）
+    spatial_param = float(model.lam)
+    
+    try:
+        spatial_param_se = float(np.sqrt(model.vm[-1, -1]))
+    except:
+        spatial_param_se = 0.0
+    
+    # 伪R方
+    try:
+        r_squared = float(model.pr2) if hasattr(model, 'pr2') else None
+    except:
+        r_squared = None
+    
+    # 对数似然值和信息准则
+    log_likelihood = float(model.logll) if hasattr(model, 'logll') else 0.0
+    aic = float(model.aic) if hasattr(model, 'aic') else 0.0
+    schwarz = float(model.schwarz) if hasattr(model, 'schwarz') else 0.0
+    
+    all_feature_names = ['const'] + feature_names
+    
+    # 生成摘要
+    summary = f"""空间误差模型 (SEM) - {method.upper()}估计:
+- 观测数量: {n}
+- 自变量数: {k}
+- 空间参数 λ: {spatial_param:.4f} (标准误: {spatial_param_se:.4f})
+- 对数似然: {log_likelihood:.2f}
+- AIC: {aic:.2f}
+- BIC: {schwarz:.2f}
+"""
+    if r_squared is not None:
+        summary += f"- 伪R²: {r_squared:.4f}\n"
+    
+    return SpatialRegressionResult(
+        model_type="SEM",
+        method=method.upper(),
+        coefficients=coefficients,
+        std_errors=std_errors,
+        z_scores=z_scores,
+        p_values=p_values,
+        feature_names=all_feature_names,
+        spatial_param=spatial_param,
+        spatial_param_se=spatial_param_se,
+        r_squared=r_squared,
+        log_likelihood=log_likelihood,
+        aic=aic,
+        schwarz=schwarz,
+        n_observations=n,
+        summary=summary
+    )

econometrics/spatial_econometrics/spatial_weights.py

@@ -0,0 +1,226 @@
+"""
+空间权重矩阵构建
+基于 libpysal 库实现多种空间权重矩阵构建方法
+"""
+
+from typing import List, Dict, Any, Optional, Tuple
+from pydantic import BaseModel, Field
+import numpy as np
+
+try:
+    from libpysal.weights import Queen, Rook, KNN, DistanceBand, Kernel
+    from libpysal.weights import W
+    LIBPYSAL_AVAILABLE = True
+except ImportError:
+    LIBPYSAL_AVAILABLE = False
+    W = None
+
+
+class SpatialWeightsResult(BaseModel):
+    """空间权重矩阵结果"""
+    n_observations: int = Field(..., description="观测数量")
+    weight_type: str = Field(..., description="权重类型")
+    n_neighbors_mean: float = Field(..., description="平均邻居数")
+    n_neighbors_min: int = Field(..., description="最小邻居数")
+    n_neighbors_max: int = Field(..., description="最大邻居数")
+    pct_nonzero: float = Field(..., description="非零权重百分比")
+    weights_matrix: List[List[float]] = Field(..., description="权重矩阵（稀疏表示）")
+    neighbors: Dict[int, List[int]] = Field(..., description="邻居字典")
+    is_symmetric: bool = Field(..., description="是否对称")
+    summary: str = Field(..., description="摘要信息")
+
+
+def create_spatial_weights(
+    coordinates: Optional[List[Tuple[float, float]]] = None,
+    adjacency_matrix: Optional[List[List[int]]] = None,
+    weight_type: str = "queen",
+    k: int = 4,
+    distance_threshold: Optional[float] = None,
+    bandwidth: Optional[float] = None,
+    kernel_type: str = "triangular",
+    row_standardize: bool = True
+) -> SpatialWeightsResult:
+    """
+    创建空间权重矩阵
+    
+    Args:
+        coordinates: 坐标列表 [(x1,y1), (x2,y2), ...]
+        adjacency_matrix: 邻接矩阵（用于基于邻接的权重）
+        weight_type: 权重类型 - "queen"(皇后邻接), "rook"(车邻接), 
+                     "knn"(K近邻), "distance"(距离带), "kernel"(核权重)
+        k: K近邻中的邻居数量
+        distance_threshold: 距离带阈值
+        bandwidth: 核权重带宽
+        kernel_type: 核函数类型
+        row_standardize: 是否进行行标准化
+        
+    Returns:
+        SpatialWeightsResult: 空间权重矩阵结果
+        
+    Raises:
+        ImportError: libpysal库未安装
+        ValueError: 输入数据无效
+    """
+    if not LIBPYSAL_AVAILABLE:
+        raise ImportError(
+            "libpysal库未安装。请运行: pip install libpysal\n"
+            "或: pip install pysal"
+        )
+    
+    # 输入验证
+    if coordinates is None and adjacency_matrix is None:
+        raise ValueError("必须提供coordinates或adjacency_matrix之一")
+    
+    # 构建空间权重对象
+    w = None
+    
+    if weight_type == "queen":
+        if adjacency_matrix is not None:
+            # 基于邻接矩阵构建
+            w = _create_from_adjacency(adjacency_matrix, "queen")
+        else:
+            raise ValueError("Queen邻接需要提供adjacency_matrix")
+            
+    elif weight_type == "rook":
+        if adjacency_matrix is not None:
+            w = _create_from_adjacency(adjacency_matrix, "rook")
+        else:
+            raise ValueError("Rook邻接需要提供adjacency_matrix")
+            
+    elif weight_type == "knn":
+        if coordinates is None:
+            raise ValueError("KNN需要提供coordinates")
+        coords_array = np.array(coordinates)
+        w = KNN.from_array(coords_array, k=k)
+        
+    elif weight_type == "distance":
+        if coordinates is None:
+            raise ValueError("距离带需要提供coordinates")
+        if distance_threshold is None:
+            raise ValueError("距离带需要提供distance_threshold")
+        coords_array = np.array(coordinates)
+        w = DistanceBand.from_array(coords_array, threshold=distance_threshold)
+        
+    elif weight_type == "kernel":
+        if coordinates is None:
+            raise ValueError("核权重需要提供coordinates")
+        coords_array = np.array(coordinates)
+        if bandwidth is None:
+            # 使用默认带宽
+            bandwidth = "auto"
+        w = Kernel.from_array(coords_array, bandwidth=bandwidth, function=kernel_type)
+        
+    else:
+        raise ValueError(
+            f"不支持的权重类型: {weight_type}。"
+            f"支持的类型: queen, rook, knn, distance, kernel"
+        )
+    
+    # 行标准化
+    if row_standardize and weight_type != "kernel":  # 核权重通常已经标准化
+        w.transform = 'r'
+    
+    # 提取结果
+    n = w.n
+    
+    # 邻居统计
+    cardinalities = w.cardinalities
+    n_neighbors_mean = float(np.mean(list(cardinalities.values())))
+    n_neighbors_min = int(min(cardinalities.values()))
+    n_neighbors_max = int(max(cardinalities.values()))
+    
+    # 非零权重百分比
+    total_possible = n * n
+    pct_nonzero = float(w.pct_nonzero)
+    
+    # 转换为稀疏矩阵表示（字典格式）
+    weights_matrix = _convert_to_sparse_matrix(w)
+    
+    # 邻居字典
+    neighbors = {int(i): [int(j) for j in w.neighbors[i]] for i in w.neighbors}
+    
+    # 检查对称性
+    is_symmetric = _check_symmetry(w)
+    
+    # 生成摘要
+    summary = f"""空间权重矩阵摘要:
+- 观测数量: {n}
+- 权重类型: {weight_type}
+- 平均邻居数: {n_neighbors_mean:.2f}
+- 邻居数范围: [{n_neighbors_min}, {n_neighbors_max}]
+- 非零权重: {pct_nonzero:.2f}%
+- 是否对称: {'是' if is_symmetric else '否'}
+- 是否行标准化: {'是' if row_standardize else '否'}
+"""
+    
+    return SpatialWeightsResult(
+        n_observations=n,
+        weight_type=weight_type,
+        n_neighbors_mean=n_neighbors_mean,
+        n_neighbors_min=n_neighbors_min,
+        n_neighbors_max=n_neighbors_max,
+        pct_nonzero=pct_nonzero,
+        weights_matrix=weights_matrix,
+        neighbors=neighbors,
+        is_symmetric=is_symmetric,
+        summary=summary
+    )
+
+
+def _create_from_adjacency(adjacency_matrix: List[List[int]], contiguity_type: str) -> W:
+    """从邻接矩阵创建空间权重"""
+    n = len(adjacency_matrix)
+    
+    # 转换为邻居字典
+    neighbors = {}
+    weights = {}
+    
+    for i in range(n):
+        neighbors[i] = []
+        weights[i] = []
+        for j in range(n):
+            if i != j and adjacency_matrix[i][j] > 0:
+                neighbors[i].append(j)
+                weights[i].append(float(adjacency_matrix[i][j]))
+    
+    # 创建权重对象
+    w = W(neighbors, weights)
+    return w
+
+
+def _convert_to_sparse_matrix(w: W) -> List[List[float]]:
+    """将权重对象转换为稀疏矩阵表示（用于返回）"""
+    # 返回前100个非零元素（避免过大）
+    sparse_repr = []
+    count = 0
+    max_elements = 100
+    
+    for i in w.neighbors:
+        for j_idx, j in enumerate(w.neighbors[i]):
+            if count >= max_elements:
+                break
+            weight = w.weights[i][j_idx]
+            sparse_repr.append([int(i), int(j), float(weight)])
+            count += 1
+        if count >= max_elements:
+            break
+    
+    return sparse_repr
+
+
+def _check_symmetry(w: W) -> bool:
+    """检查权重矩阵是否对称"""
+    try:
+        # 简单检查：对于每个i->j，是否存在j->i
+        for i in w.neighbors:
+            for j_idx, j in enumerate(w.neighbors[i]):
+                # 检查j的邻居中是否有i
+                if i not in w.neighbors.get(j, []):
+                    return False
+                # 检查权重是否相同
+                j_i_idx = w.neighbors[j].index(i)
+                if abs(w.weights[i][j_idx] - w.weights[j][j_i_idx]) > 1e-10:
+                    return False
+        return True
+    except:
+        return False

econometrics/specific_data_modeling/micro_discrete_limited_data/README.md

@@ -0,0 +1,164 @@
+# 微观离散与受限数据模型
+
+该模块实现了微观计量经济学中常用的离散选择模型和受限因变量模型，适用于因变量为分类、计数、截断等非连续情况的数据分析。本模块基于statsmodels等现有库构建，避免重复造轮子。
+
+## 依赖库
+
+- statsmodels >= 0.13.0
+- numpy
+- pandas
+- scipy
+
+安装依赖：
+```bash
+pip install statsmodels numpy pandas scipy
+```
+
+## 模型列表
+
+### 离散选择模型
+
+1. **LogitModel** - Logistic回归模型
+   - 基于statsmodels的Logit模型实现
+   - 适用于二元选择问题
+
+2. **ProbitModel** - Probit回归模型
+   - 基于statsmodels的Probit模型实现
+   - 基于正态分布假设
+
+3. **MultinomialLogit** - 多项Logit模型
+   - 基于statsmodels的MNLogit模型实现
+   - 适用于无序多分类选择问题
+
+4. **OrderedLogit** - 有序Logit模型
+   - 基于statsmodels的OrderedModel实现
+   - 适用于有序多分类选择问题
+
+5. **ConditionalLogit** - 条件Logit模型
+   - 基于statsmodels的ConditionalLogit实现
+   - 适用于配对选择等条件选择模型
+
+### 受限因变量模型
+
+1. **TobitModel** - Tobit模型（截断回归模型）
+   - 基于statsmodels的Tobit模型实现
+   - 适用于因变量在某个阈值处被截断的情况
+   - 支持上下界截断
+
+2. **HeckmanModel** - Heckman两阶段选择模型
+   - 基于statsmodels构建的两阶段选择模型
+   - 用于处理样本选择偏差问题
+
+### 计数数据模型
+
+1. **PoissonModel** - 泊松回归模型
+   - 基于statsmodels的Poisson模型实现
+   - 适用于计数数据建模
+   - 假设均值等于方差
+
+2. **NegativeBinomialModel** - 负二项回归模型
+   - 基于statsmodels的NegativeBinomial模型实现
+   - 适用于过度离散的计数数据
+   - 允许方差大于均值
+
+3. **ZeroInflatedPoissonModel** - 零膨胀泊松模型
+   - 基于statsmodels的ZeroInflatedPoisson实现
+   - 适用于零值过多的计数数据
+
+4. **ZeroInflatedNegativeBinomialModel** - 零膨胀负二项模型
+   - 基于statsmodels的ZeroInflatedNegativeBinomialP实现
+   - 适用于零值过多且过度离散的计数数据
+
+## 使用示例
+
+### Logit模型示例
+
+```python
+from econometrics.specific_data_modeling.micro_discrete_limited_data import LogitModel
+import numpy as np
+
+# 生成示例数据
+X = np.random.normal(0, 1, (1000, 2))
+y = np.random.binomial(1, 1 / (1 + np.exp(-(0.5*X[:, 0] - 0.3*X[:, 1]))))
+
+# 拟合模型
+model = LogitModel()
+model.fit(X, y)
+
+# 预测
+probabilities = model.predict_proba(X)
+predictions = model.predict(X)
+
+# 查看模型摘要
+print(model.summary())
+```
+
+### Tobit模型示例
+
+```python
+from econometrics.specific_data_modeling.micro_discrete_limited_data import TobitModel
+import numpy as np
+
+# 生成示例数据
+X = np.random.normal(0, 1, (1000, 2))
+y_latent = 1.0*X[:, 0] - 0.5*X[:, 1] + np.random.normal(0, 0.5, 1000)
+y = np.maximum(y_latent, 0)  # 左截断于0
+
+# 拟合模型
+model = TobitModel(lower_bound=0)
+model.fit(X, y)
+
+# 预测
+predictions = model.predict(X)
+
+# 查看模型摘要
+print(model.summary())
+```
+
+### 泊松模型示例
+
+```python
+from econometrics.specific_data_modeling.micro_discrete_limited_data import PoissonModel
+import numpy as np
+
+# 生成示例数据
+X = np.random.normal(0, 1, (1000, 2))
+mu = np.exp(0.5*X[:, 0] - 0.3*X[:, 1])
+y = np.random.poisson(mu)
+
+# 拟合模型
+model = PoissonModel()
+model.fit(X, y)
+
+# 预测
+predictions = model.predict(X)
+
+# 查看模型摘要
+print(model.summary())
+```
+
+## 模型输出
+
+所有模型都提供以下输出：
+- 参数估计值 (通过.results_.params访问)
+- 标准误差 (通过.results_.bse访问)
+- t统计量 (通过.results_.tvalues访问)
+- p值 (通过.results_.pvalues访问)
+- 模型拟合统计量 (AIC, BIC, 对数似然等)
+- 预测方法 (predict, predict_proba等)
+- 模型摘要 (summary方法)
+
+## 注意事项
+
+1. 数据预处理：确保数据符合模型假设
+2. 模型诊断：检查模型拟合优度和残差
+3. 过度离散：对于计数数据，如果存在过度离散，应使用负二项模型而非泊松模型
+4. 边界值处理：模型中已对数值边界情况进行处理，但用户仍需注意数据质量
+5. 依赖库：确保安装了statsmodels等依赖库
+
+## 参考文献
+
+1. Cameron, A. C., & Trivedi, P. K. (2013). Regression analysis of count data. Cambridge university press.
+2. Greene, W. H. (2003). Econometric analysis. Pearson Education India.
+3. Wooldridge, J. M. (2010). Econometric analysis of cross section and panel data. MIT press.
+4. Statsmodels Documentation: https://www.statsmodels.org/stable/index.html