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

econometrics/advanced_methods/modern_computing_machine_learning/double_ml.py

@@ -0,0 +1,268 @@
+"""
+Double Machine Learning implementation for causal inference
+"""
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.metrics import mean_squared_error
+from typing import Union, Optional, Dict, Any, Tuple
+from scipy import stats
+
+
+class DoubleML:
+    """
+    Double Machine Learning for causal inference with treatment effects
+    """
+    
+    def __init__(self, learner_g: Any = None, learner_m: Any = None,
+                 treatment_type: str = 'continuous', n_folds: int = 5,
+                 random_state: int = 42):
+        """
+        Initialize Double Machine Learning model
+        
+        Parameters:
+        -----------
+        learner_g : sklearn estimator, optional
+            Estimator for the outcome regression (g)
+            Default: RandomForestRegressor for continuous, RandomForestClassifier for binary
+        learner_m : sklearn estimator, optional
+            Estimator for the treatment regression (m)
+            Default: RandomForestRegressor for continuous, RandomForestClassifier for binary
+        treatment_type : str, 'continuous' or 'binary'
+            Type of treatment variable
+        n_folds : int
+            Number of cross-fitting folds
+        random_state : int
+            Random state for reproducibility
+        """
+        self.learner_g = learner_g
+        self.learner_m = learner_m
+        self.treatment_type = treatment_type
+        self.n_folds = n_folds
+        self.random_state = random_state
+        
+        # Set default learners if not provided
+        if self.learner_g is None:
+            if treatment_type == 'continuous':
+                self.learner_g = RandomForestRegressor(n_estimators=100, random_state=random_state)
+            else:
+                self.learner_g = RandomForestClassifier(n_estimators=100, random_state=random_state)
+        
+        if self.learner_m is None:
+            if treatment_type == 'continuous':
+                self.learner_m = RandomForestRegressor(n_estimators=100, random_state=random_state)
+            else:
+                self.learner_m = RandomForestClassifier(n_estimators=100, random_state=random_state)
+        
+        # Store results
+        self.effect = None
+        self.se = None
+        self.ci = None
+        self.pval = None
+    
+    def fit(self, X: Union[np.ndarray, pd.DataFrame], 
+            y: Union[np.ndarray, pd.Series],
+            d: Union[np.ndarray, pd.Series]) -> 'DoubleML':
+        """
+        Fit the Double Machine Learning model
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Covariates
+        y : array-like of shape (n_samples,)
+            Outcome variable
+        d : array-like of shape (n_samples,)
+            Treatment variable
+            
+        Returns:
+        --------
+        self : DoubleML
+        """
+        # Convert to numpy arrays if needed
+        X = np.asarray(X)
+        y = np.asarray(y)
+        d = np.asarray(d)
+        
+        n_samples = X.shape[0]
+        
+        # Initialize arrays to store residuals
+        y_res = np.zeros(n_samples)
+        d_res = np.zeros(n_samples)
+        
+        # Create folds for cross-fitting
+        np.random.seed(self.random_state)
+        indices = np.random.permutation(n_samples)
+        fold_size = n_samples // self.n_folds
+        folds = [indices[i*fold_size:(i+1)*fold_size] for i in range(self.n_folds)]
+        # Add remaining samples to the last fold
+        if n_samples % self.n_folds != 0:
+            folds[-1] = np.concatenate([folds[-1], indices[self.n_folds*fold_size:]])
+        
+        # Cross-fitting
+        for fold_idx, test_idx in enumerate(folds):
+            # Training indices (all except test fold)
+            train_idx = np.concatenate([folds[i] for i in range(self.n_folds) if i != fold_idx])
+            
+            # Split data
+            X_train, X_test = X[train_idx], X[test_idx]
+            y_train, y_test = y[train_idx], y[test_idx]
+            d_train, d_test = d[train_idx], d[test_idx]
+            
+            # Fit outcome regression and get residuals
+            self.learner_g.fit(X_train, y_train)
+            if self.treatment_type == 'continuous':
+                y_pred = self.learner_g.predict(X_test)
+            else:
+                y_pred = self.learner_g.predict_proba(X_test)[:, 1]
+            y_res[test_idx] = y_test - y_pred
+            
+            # Fit treatment regression and get residuals
+            self.learner_m.fit(X_train, d_train)
+            if self.treatment_type == 'continuous':
+                d_pred = self.learner_m.predict(X_test)
+            else:
+                d_pred = self.learner_m.predict_proba(X_test)[:, 1]
+            d_res[test_idx] = d_test - d_pred
+        
+        # Estimate treatment effect using partially linear regression
+        # theta = E[d_res * y_res] / E[d_res^2]
+        numerator = np.mean(d_res * y_res)
+        denominator = np.mean(d_res**2)
+        
+        self.effect = numerator / denominator
+        
+        # Calculate standard error
+        # Using the formula for the variance of the DML estimator
+        residuals = y_res - self.effect * d_res
+        variance = np.mean(residuals**2) / np.mean(d_res**2)**2 / n_samples
+        self.se = np.sqrt(variance)
+        
+        # Calculate 95% confidence interval
+        crit_val = 1.96  # 95% CI
+        self.ci = (self.effect - crit_val * self.se, 
+                   self.effect + crit_val * self.se)
+        
+        # Calculate p-value (two-sided test)
+        z_score = self.effect / self.se
+        # Use scipy.stats.norm for calculating p-value
+        self.pval = 2 * (1 - stats.norm.cdf(np.abs(z_score)))
+        
+        return self
+    
+    def predict(self, X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray:
+        """
+        Predict treatment effects (constant for this implementation)
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Samples (not used, treatment effect is constant)
+            
+        Returns:
+        --------
+        effects : ndarray of shape (n_samples,)
+            Estimated treatment effects
+        """
+        return np.full(X.shape[0], self.effect) if hasattr(X, 'shape') else np.full(len(X), self.effect)
+    
+    def get_effect(self) -> float:
+        """
+        Get the estimated treatment effect
+        
+        Returns:
+        --------
+        effect : float
+            Estimated treatment effect
+        """
+        return self.effect
+    
+    def get_se(self) -> float:
+        """
+        Get the standard error of the treatment effect
+        
+        Returns:
+        --------
+        se : float
+            Standard error of the treatment effect
+        """
+        return self.se
+    
+    def get_ci(self) -> Tuple[float, float]:
+        """
+        Get the 95% confidence interval for the treatment effect
+        
+        Returns:
+        --------
+        ci : tuple
+            95% confidence interval (lower, upper)
+        """
+        return self.ci
+    
+    def get_pval(self) -> float:
+        """
+        Get the p-value for the treatment effect
+        
+        Returns:
+        --------
+        pval : float
+            P-value for the treatment effect
+        """
+        return self.pval
+
+
+def double_ml_analysis(X: Union[np.ndarray, pd.DataFrame], 
+                      y: Union[np.ndarray, pd.Series],
+                      d: Union[np.ndarray, pd.Series],
+                      treatment_type: str = 'continuous',
+                      n_folds: int = 5,
+                      random_state: int = 42) -> dict:
+    """
+    Perform complete Double Machine Learning analysis
+    
+    Parameters:
+    -----------
+    X : array-like of shape (n_samples, n_features)
+        Covariates
+    y : array-like of shape (n_samples,)
+        Outcome variable
+    d : array-like of shape (n_samples,)
+        Treatment variable
+    treatment_type : str, 'continuous' or 'binary'
+        Type of treatment variable
+    n_folds : int
+        Number of cross-fitting folds
+    random_state : int
+        Random state for reproducibility
+        
+    Returns:
+    --------
+    results : dict
+        Dictionary with model and estimation results
+    """
+    # Initialize and fit model
+    dml_model = DoubleML(
+        treatment_type=treatment_type,
+        n_folds=n_folds,
+        random_state=random_state
+    )
+    dml_model.fit(X, y, d)
+    
+    # Get results
+    effect = dml_model.get_effect()
+    se = dml_model.get_se()
+    ci = dml_model.get_ci()
+    pval = dml_model.get_pval()
+    
+    return {
+        'model': dml_model,
+        'effect': effect,
+        'se': se,
+        'ci': ci,
+        'pval': pval,
+        'X': X,
+        'y': y,
+        'd': d
+    }

econometrics/advanced_methods/modern_computing_machine_learning/gradient_boosting.py

@@ -0,0 +1,249 @@
+"""
+Gradient Boosting Machine (GBM/XGBoost) implementation for econometric analysis
+"""
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, accuracy_score
+try:
+    import xgboost as xgb
+    XGBOOST_AVAILABLE = True
+except ImportError:
+    XGBOOST_AVAILABLE = False
+from typing import Union, Optional, Dict, Any
+
+
+class EconGradientBoosting:
+    """
+    Gradient Boosting for econometric analysis with both scikit-learn and XGBoost implementations
+    """
+    
+    def __init__(self, algorithm: str = 'sklearn', problem_type: str = 'regression',
+                 n_estimators: int = 100, learning_rate: float = 0.1, 
+                 max_depth: int = 3, random_state: int = 42):
+        """
+        Initialize Gradient Boosting model
+        
+        Parameters:
+        -----------
+        algorithm : str, 'sklearn' or 'xgboost'
+            Which implementation to use
+        problem_type : str, 'regression' or 'classification'
+            Type of problem to solve
+        n_estimators : int
+            Number of boosting stages
+        learning_rate : float
+            Learning rate shrinks the contribution of each tree
+        max_depth : int
+            Maximum depth of the individual regression estimators
+        random_state : int
+            Random state for reproducibility
+        """
+        self.algorithm = algorithm
+        self.problem_type = problem_type
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+        self.random_state = random_state
+        
+        if algorithm == 'sklearn':
+            if problem_type == 'regression':
+                self.model = GradientBoostingRegressor(
+                    n_estimators=n_estimators,
+                    learning_rate=learning_rate,
+                    max_depth=max_depth,
+                    random_state=random_state
+                )
+            elif problem_type == 'classification':
+                self.model = GradientBoostingClassifier(
+                    n_estimators=n_estimators,
+                    learning_rate=learning_rate,
+                    max_depth=max_depth,
+                    random_state=random_state
+                )
+        elif algorithm == 'xgboost':
+            if not XGBOOST_AVAILABLE:
+                raise ImportError("XGBoost is not installed. Please install it with 'pip install xgboost'")
+            
+            if problem_type == 'regression':
+                self.model = xgb.XGBRegressor(
+                    n_estimators=n_estimators,
+                    learning_rate=learning_rate,
+                    max_depth=max_depth,
+                    random_state=random_state
+                )
+            elif problem_type == 'classification':
+                self.model = xgb.XGBClassifier(
+                    n_estimators=n_estimators,
+                    learning_rate=learning_rate,
+                    max_depth=max_depth,
+                    random_state=random_state
+                )
+        else:
+            raise ValueError("algorithm must be either 'sklearn' or 'xgboost'")
+    
+    def fit(self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, pd.Series]) -> 'EconGradientBoosting':
+        """
+        Fit the Gradient Boosting model
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Training data
+        y : array-like of shape (n_samples,)
+            Target values
+            
+        Returns:
+        --------
+        self : EconGradientBoosting
+        """
+        self.model.fit(X, y)
+        return self
+    
+    def predict(self, X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray:
+        """
+        Predict using the Gradient Boosting model
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Samples
+            
+        Returns:
+        --------
+        y_pred : ndarray of shape (n_samples,)
+            Predicted values
+        """
+        return self.model.predict(X)
+    
+    def feature_importance(self) -> Dict[str, np.ndarray]:
+        """
+        Get feature importances
+        
+        Returns:
+        --------
+        importances : dict
+            Dictionary with feature importances (depends on algorithm)
+        """
+        if self.algorithm == 'sklearn':
+            return {
+                'importances': self.model.feature_importances_
+            }
+        elif self.algorithm == 'xgboost':
+            # XGBoost provides multiple importance types
+            importance_types = ['weight', 'gain', 'cover', 'total_gain', 'total_cover']
+            importances = {}
+            for imp_type in importance_types:
+                try:
+                    importances[imp_type] = self.model.feature_importances_
+                except:
+                    pass
+            return importances
+    
+    def evaluate(self, X: Union[np.ndarray, pd.DataFrame], 
+                 y: Union[np.ndarray, pd.Series]) -> dict:
+        """
+        Evaluate model performance
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Test data
+        y : array-like of shape (n_samples,)
+            True values
+            
+        Returns:
+        --------
+        metrics : dict
+            Dictionary with evaluation metrics
+        """
+        y_pred = self.predict(X)
+        
+        if self.problem_type == 'regression':
+            mse = mean_squared_error(y, y_pred)
+            rmse = np.sqrt(mse)
+            return {
+                'mse': mse,
+                'rmse': rmse,
+                'predictions': y_pred
+            }
+        else:
+            accuracy = accuracy_score(y, y_pred)
+            return {
+                'accuracy': accuracy,
+                'predictions': y_pred
+            }
+
+
+def gradient_boosting_analysis(X: Union[np.ndarray, pd.DataFrame], 
+                              y: Union[np.ndarray, pd.Series],
+                              algorithm: str = 'sklearn',
+                              problem_type: str = 'regression',
+                              test_size: float = 0.2,
+                              n_estimators: int = 100,
+                              learning_rate: float = 0.1,
+                              max_depth: int = 3,
+                              random_state: int = 42) -> dict:
+    """
+    Perform complete Gradient Boosting analysis
+    
+    Parameters:
+    -----------
+    X : array-like of shape (n_samples, n_features)
+        Features
+    y : array-like of shape (n_samples,)
+        Target variable
+    algorithm : str, 'sklearn' or 'xgboost'
+        Which implementation to use
+    problem_type : str, 'regression' or 'classification'
+        Type of problem to solve
+    test_size : float
+        Proportion of dataset to include in test split
+    n_estimators : int
+        Number of boosting stages
+    learning_rate : float
+        Learning rate shrinks the contribution of each tree
+    max_depth : int
+        Maximum depth of the individual regression estimators
+    random_state : int
+        Random state for reproducibility
+        
+    Returns:
+    --------
+    results : dict
+        Dictionary with model, predictions, and feature importances
+    """
+    # Split data
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state
+    )
+    
+    # Initialize and fit model
+    gb_model = EconGradientBoosting(
+        algorithm=algorithm,
+        problem_type=problem_type,
+        n_estimators=n_estimators,
+        learning_rate=learning_rate,
+        max_depth=max_depth,
+        random_state=random_state
+    )
+    gb_model.fit(X_train, y_train)
+    
+    # Evaluate model
+    train_results = gb_model.evaluate(X_train, y_train)
+    test_results = gb_model.evaluate(X_test, y_test)
+    
+    # Get feature importances
+    importances = gb_model.feature_importance()
+    
+    return {
+        'model': gb_model,
+        'train_results': train_results,
+        'test_results': test_results,
+        'feature_importances': importances,
+        'X_train': X_train,
+        'X_test': X_test,
+        'y_train': y_train,
+        'y_test': y_test
+    }