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

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
+    }

econometrics/advanced_methods/modern_computing_machine_learning/hierarchical_clustering.py

@@ -0,0 +1,243 @@
+"""
+Hierarchical Clustering implementation for econometric analysis
+"""
+import numpy as np
+import pandas as pd
+from sklearn.cluster import AgglomerativeClustering, linkage_tree
+from sklearn.metrics import silhouette_score, calinski_harabasz_score
+from sklearn.preprocessing import StandardScaler
+from scipy.cluster.hierarchy import dendrogram, linkage, fcluster
+from scipy.spatial.distance import pdist
+from typing import Union, Optional, Dict, Any
+
+# 可选导入matplotlib
+try:
+    import matplotlib.pyplot as plt
+    MATPLOTLIB_AVAILABLE = True
+except ImportError:
+    MATPLOTLIB_AVAILABLE = False
+except UnicodeDecodeError:
+    # 处理编码问题
+    MATPLOTLIB_AVAILABLE = False
+
+
+class EconHierarchicalClustering:
+    """
+    Hierarchical Clustering for econometric analysis
+    """
+    
+    def __init__(self, n_clusters: int = 2, linkage: str = 'ward', 
+                 metric: str = 'euclidean'):
+        """
+        Initialize Hierarchical Clustering model
+        
+        Parameters:
+        -----------
+        n_clusters : int
+            Number of clusters to find
+        linkage : str, 'ward', 'complete', 'average', 'single'
+            Which linkage criterion to use
+        metric : str or callable
+            Metric used to compute the linkage. Can be 'euclidean', 'l1', 'l2',
+            'manhattan', 'cosine', or 'precomputed'
+        """
+        self.n_clusters = n_clusters
+        self.linkage = linkage
+        self.metric = metric
+        self.scaler = StandardScaler()
+        
+        # Initialize model
+        # Note: 'ward' linkage requires 'euclidean' metric
+        if linkage == 'ward':
+            self.metric = 'euclidean'
+            
+        self.model = AgglomerativeClustering(
+            n_clusters=n_clusters,
+            linkage=linkage,
+            metric=metric if linkage != 'ward' else 'euclidean'
+        )
+        
+        # Store linkage matrix for dendrogram
+        self.linkage_matrix = None
+    
+    def fit(self, X: Union[np.ndarray, pd.DataFrame]) -> 'EconHierarchicalClustering':
+        """
+        Fit the Hierarchical Clustering model
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Training data
+            
+        Returns:
+        --------
+        self : EconHierarchicalClustering
+        """
+        # Scale features
+        X_scaled = self.scaler.fit_transform(X)
+        
+        # Fit the model
+        self.model.fit(X_scaled)
+        
+        # Compute linkage matrix for dendrogram
+        if self.metric != 'precomputed':
+            distance_matrix = pdist(X_scaled, metric=self.metric)
+            self.linkage_matrix = linkage(distance_matrix, method=self.linkage)
+        
+        return self
+    
+    def predict(self, X: Union[np.ndarray, pd.DataFrame] = None) -> np.ndarray:
+        """
+        Get cluster labels
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features) or None
+            Data to predict (not used in hierarchical clustering, 
+            returns labels from fit)
+            
+        Returns:
+        --------
+        labels : ndarray of shape (n_samples,)
+            Index of the cluster each sample belongs to
+        """
+        return self.model.labels_
+    
+    def fit_predict(self, X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray:
+        """
+        Fit the hierarchical clustering model and return cluster labels
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Training data
+            
+        Returns:
+        --------
+        labels : ndarray of shape (n_samples,)
+            Index of the cluster each sample belongs to
+        """
+        self.fit(X)
+        return self.model.labels_
+    
+    def evaluate(self, X: Union[np.ndarray, pd.DataFrame]) -> Dict[str, float]:
+        """
+        Evaluate clustering performance
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features)
+            Data to evaluate
+            
+        Returns:
+        --------
+        metrics : dict
+            Dictionary with evaluation metrics
+        """
+        # Scale features
+        X_scaled = self.scaler.transform(X)
+        labels = self.model.labels_
+        
+        # Calculate metrics if more than 1 cluster
+        if len(np.unique(labels)) > 1:
+            silhouette = silhouette_score(X_scaled, labels)
+            calinski_harabasz = calinski_harabasz_score(X_scaled, labels)
+        else:
+            silhouette = 0.0
+            calinski_harabasz = 0.0
+        
+        return {
+            'silhouette_score': silhouette,
+            'calinski_harabasz_score': calinski_harabasz
+        }
+    
+    def plot_dendrogram(self, X: Union[np.ndarray, pd.DataFrame] = None, 
+                       truncate_mode: str = 'level', p: int = 5,
+                       figsize: tuple = (12, 8)) -> Optional:
+        """
+        Plot dendrogram for hierarchical clustering
+        
+        Parameters:
+        -----------
+        X : array-like of shape (n_samples, n_features) or None
+            Data to visualize (if None, uses data from fit)
+        truncate_mode : str
+            Truncation mode for dendrogram
+        p : int
+            Parameter for truncation
+        figsize : tuple
+            Figure size
+            
+        Returns:
+        --------
+        fig : matplotlib Figure or None
+            The figure object, or None if matplotlib is not available
+        """
+        if not MATPLOTLIB_AVAILABLE:
+            print("Matplotlib is not available. Skipping visualization.")
+            return None
+            
+        # Compute linkage matrix if not already computed
+        if self.linkage_matrix is None and X is not None:
+            X_scaled = self.scaler.transform(X)
+            distance_matrix = pdist(X_scaled, metric=self.metric)
+            self.linkage_matrix = linkage(distance_matrix, method=self.linkage)
+        
+        if self.linkage_matrix is None:
+            raise ValueError("No linkage matrix available. Please fit the model first or provide data.")
+        
+        # Create plot
+        fig, ax = plt.subplots(figsize=figsize)
+        dendrogram(
+            self.linkage_matrix,
+            truncate_mode=truncate_mode,
+            p=p,
+            ax=ax
+        )
+        ax.set_xlabel('Sample Index or (Cluster Size)')
+        ax.set_ylabel('Distance')
+        ax.set_title('Hierarchical Clustering Dendrogram')
+        
+        return fig
+
+
+def hierarchical_clustering_analysis(X: Union[np.ndarray, pd.DataFrame],
+                                   n_clusters: int = 2,
+                                   linkage: str = 'ward',
+                                   metric: str = 'euclidean') -> dict:
+    """
+    Perform complete Hierarchical Clustering analysis
+    
+    Parameters:
+    -----------
+    X : array-like of shape (n_samples, n_features)
+        Features
+    n_clusters : int
+        Number of clusters to find
+    linkage : str, 'ward', 'complete', 'average', 'single'
+        Which linkage criterion to use
+    metric : str or callable
+        Metric used to compute the linkage
+        
+    Returns:
+    --------
+    results : dict
+        Dictionary with model, cluster labels, and evaluation metrics
+    """
+    # Initialize and fit model
+    hc_model = EconHierarchicalClustering(
+        n_clusters=n_clusters,
+        linkage=linkage,
+        metric=metric
+    )
+    labels = hc_model.fit_predict(X)
+    
+    # Evaluate clustering
+    metrics = hc_model.evaluate(X)
+    
+    return {
+        'model': hc_model,
+        'labels': labels,
+        'metrics': metrics,
+        'X': X
+    }