unifiedbooster 0.9.0__py3-none-any.whl

unifiedbooster/__init__.py

@@ -0,0 +1,12 @@
+from .gbdt import GBDT
+from .gbdt_classification import GBDTClassifier
+from .gbdt_regression import GBDTRegressor
+from .gpoptimization import cross_val_optim, lazy_cross_val_optim
+
+__all__ = [
+    "GBDT",
+    "GBDTClassifier",
+    "GBDTRegressor",
+    "cross_val_optim",
+    "lazy_cross_val_optim",
+]

unifiedbooster/gbdt.py

@@ -0,0 +1,161 @@
+import numpy as np
+from sklearn.base import BaseEstimator
+
+
+class GBDT(BaseEstimator):
+    """Gradient Boosted Decision Trees (GBDT) base class
+
+    Attributes:
+
+        model_type: str
+            type of gradient boosting algorithm: 'xgboost', 'lightgbm',
+            'catboost', 'gradientboosting'
+
+        n_estimators: int
+            maximum number of trees that can be built
+
+        learning_rate: float
+            shrinkage rate; used for reducing the gradient step
+
+        max_depth: int
+            maximum tree depth
+
+        rowsample: float
+            subsample ratio of the training instances
+
+        colsample: float
+            percentage of features to use at each node split
+
+        verbose: int
+            controls verbosity (default=0)
+
+        seed: int
+            reproducibility seed
+
+        **kwargs: dict
+            additional parameters to be passed to the class
+    """
+
+    def __init__(
+        self,
+        model_type="xgboost",
+        n_estimators=100,
+        learning_rate=0.1,
+        max_depth=3,
+        rowsample=1.0,
+        colsample=1.0,
+        level=None,
+        pi_method=None,
+        verbose=0,
+        seed=123,
+        **kwargs
+    ):
+
+        self.model_type = model_type
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+        self.rowsample = rowsample
+        self.colsample = colsample
+        self.level = level
+        self.pi_method = pi_method
+        self.verbose = verbose
+        self.seed = seed
+
+        if self.model_type == "xgboost":
+            self.params = {
+                "n_estimators": self.n_estimators,
+                "learning_rate": self.learning_rate,
+                "subsample": self.rowsample,
+                "colsample_bynode": self.colsample,
+                "max_depth": self.max_depth,
+                "verbosity": self.verbose,
+                "seed": self.seed,
+                **kwargs,
+            }
+        elif self.model_type == "lightgbm":
+            verbose = self.verbose - 1 if self.verbose == 0 else self.verbose
+            self.params = {
+                "n_estimators": self.n_estimators,
+                "learning_rate": self.learning_rate,
+                "subsample": self.rowsample,
+                "feature_fraction_bynode": self.colsample,
+                "max_depth": self.max_depth,
+                "verbose": verbose,  # keep this way
+                "seed": self.seed,
+                **kwargs,
+            }
+        elif self.model_type == "catboost":
+            self.params = {
+                "iterations": self.n_estimators,
+                "learning_rate": self.learning_rate,
+                "subsample": self.rowsample,
+                "rsm": self.colsample,
+                "depth": self.max_depth,
+                "verbose": self.verbose,
+                "random_seed": self.seed,
+                "boosting_type": "Plain",
+                "leaf_estimation_iterations": 1,
+                "bootstrap_type": "Bernoulli",
+                **kwargs,
+            }
+        elif self.model_type == "gradientboosting":
+            self.params = {
+                "n_estimators": self.n_estimators,
+                "learning_rate": self.learning_rate,
+                "subsample": self.rowsample,
+                "max_features": self.colsample,
+                "max_depth": self.max_depth,
+                "verbose": self.verbose,
+                "random_state": self.seed,
+                **kwargs,
+            }
+
+    def fit(self, X, y, **kwargs):
+        """Fit custom model to training data (X, y).
+
+        Parameters:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features.
+
+            y: array-like, shape = [n_samples]
+                Target values.
+
+            **kwargs: additional parameters to be passed to
+                        self.cook_training_set or self.obj.fit
+
+        Returns:
+
+            self: object
+        """
+        if getattr(self, "type_fit") == "classification":
+            self.classes_ = np.unique(y)  # for compatibility with sklearn
+            self.n_classes_ = len(
+                self.classes_
+            )  # for compatibility with sklearn
+        if getattr(self, "model_type") == "gradientboosting":
+            self.model.max_features = int(self.model.max_features * X.shape[1])
+        return getattr(self, "model").fit(X, y, **kwargs)
+
+    def predict(self, X):
+        """Predict test data X.
+
+        Parameters:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features.
+
+            **kwargs: additional parameters to be passed to
+                    self.cook_test_set
+
+        Returns:
+
+            model predictions: {array-like}
+        """
+        if self.level is not None and self.type_fit == "regression":
+            return getattr(self, "model").predict(X, return_pi=True)
+        else:
+            return getattr(self, "model").predict(X)

unifiedbooster/gbdt_classification.py

@@ -0,0 +1,188 @@
+from .gbdt import GBDT
+from sklearn.base import ClassifierMixin
+from .predictionset import PredictionSet
+
+try:
+    from xgboost import XGBClassifier
+except:
+    pass
+try:
+    from catboost import CatBoostClassifier
+except:
+    pass
+try:
+    from lightgbm import LGBMClassifier
+except:
+    pass
+from sklearn.ensemble import GradientBoostingClassifier
+
+
+class GBDTClassifier(GBDT, ClassifierMixin):
+    """GBDT Classification model
+
+    Attributes:
+
+        model_type: str
+            type of gradient boosting algorithm: 'xgboost', 'lightgbm',
+            'catboost', 'gradientboosting'
+
+        n_estimators: int
+            maximum number of trees that can be built
+
+        learning_rate: float
+            shrinkage rate; used for reducing the gradient step
+
+        max_depth: int
+            maximum tree depth
+
+        rowsample: float
+            subsample ratio of the training instances
+
+        colsample: float
+            percentage of features to use at each node split
+
+        level: float
+            confidence level for prediction sets
+
+        pi_method: str
+            method for constructing the prediction intervals: 'icp' (inductive conformal), 'tcp' (transductive conformal)
+
+        verbose: int
+            controls verbosity (default=0)
+
+        seed: int
+            reproducibility seed
+
+        **kwargs: dict
+            additional parameters to be passed to the class
+
+    Examples:
+
+        ```python
+        import unifiedbooster as ub
+        from sklearn.datasets import load_iris
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import accuracy_score
+
+        # Load dataset
+        iris = load_iris()
+        X, y = iris.data, iris.target
+
+        # Split dataset into training and testing sets
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+        # Initialize the unified regressor (example with XGBoost)
+        regressor1 = ub.GBDTClassifier(model_type='xgboost')
+        #regressor2 = ub.GBDTClassifier(model_type='catboost')
+        regressor3 = ub.GBDTClassifier(model_type='lightgbm')
+
+        # Fit the model
+        regressor1.fit(X_train, y_train)
+        #regressor2.fit(X_train, y_train)
+        regressor3.fit(X_train, y_train)
+
+        # Predict on the test set
+        y_pred1 = regressor1.predict(X_test)
+        #y_pred2 = regressor2.predict(X_test)
+        y_pred3 = regressor3.predict(X_test)
+
+        # Evaluate the model
+        accuracy1 = accuracy_score(y_test, y_pred1)
+        #accuracy2 = accuracy_score(y_test, y_pred2)
+        accuracy3 = accuracy_score(y_test, y_pred3)
+        print(f"Classification Accuracy xgboost: {accuracy1:.2f}")
+        #print(f"Classification Accuracy catboost: {accuracy2:.2f}")
+        print(f"Classification Accuracy lightgbm: {accuracy3:.2f}")
+        ```
+    """
+
+    def __init__(
+        self,
+        model_type="xgboost",
+        n_estimators=100,
+        learning_rate=0.1,
+        max_depth=3,
+        rowsample=1.0,
+        colsample=1.0,
+        level=None,
+        pi_method="icp",
+        verbose=0,
+        seed=123,
+        **kwargs,
+    ):
+
+        self.type_fit = "classification"
+
+        super().__init__(
+            model_type=model_type,
+            n_estimators=n_estimators,
+            learning_rate=learning_rate,
+            max_depth=max_depth,
+            rowsample=rowsample,
+            colsample=colsample,
+            level=level,
+            pi_method=pi_method,
+            verbose=verbose,
+            seed=seed,
+            **kwargs,
+        )
+
+        if self.level is not None:
+
+            if model_type in ("xgboost", "xgb"):
+                self.model = PredictionSet(
+                    XGBClassifier(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                )
+            elif model_type in ("catboost", "cb"):
+                self.model = PredictionSet(
+                    CatBoostClassifier(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                )
+            elif model_type in ("lightgbm", "lgb"):
+                self.model = PredictionSet(
+                    LGBMClassifier(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                )
+            elif model_type in ("gradientboosting", "gb"):
+                self.model = PredictionSet(
+                    GradientBoostingClassifier(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                )
+            else:
+                raise ValueError(f"Unknown model_type: {model_type}")
+
+        else:
+
+            if model_type in ("xgboost", "xgb"):
+                self.model = XGBClassifier(**self.params)
+            elif model_type in ("catboost", "cb"):
+                self.model = CatBoostClassifier(**self.params)
+            elif model_type in ("lightgbm", "lgb"):
+                self.model = LGBMClassifier(**self.params)
+            elif model_type in ("gradientboosting", "gb"):
+                self.model = GradientBoostingClassifier(**self.params)
+            else:
+                raise ValueError(f"Unknown model_type: {model_type}")
+
+    def predict_proba(self, X):
+        """Predict probabilities for test data X.
+
+        Args:
+
+            X: {array-like}, shape = [n_samples, n_features]
+                Training vectors, where n_samples is the number
+                of samples and n_features is the number of features.
+
+            **kwargs: additional parameters to be passed to
+                    self.cook_test_set
+
+        Returns:
+
+            probability estimates for test data: {array-like}
+        """
+        return self.model.predict_proba(X)

unifiedbooster/gbdt_regression.py

@@ -0,0 +1,180 @@
+from .gbdt import GBDT
+from sklearn.base import RegressorMixin
+from .predictioninterval import PredictionInterval
+
+try:
+    from xgboost import XGBRegressor
+except:
+    pass
+try:
+    from catboost import CatBoostRegressor
+except:
+    pass
+try:
+    from lightgbm import LGBMRegressor
+except:
+    pass
+from sklearn.ensemble import GradientBoostingRegressor
+
+
+class GBDTRegressor(GBDT, RegressorMixin):
+    """GBDT Regression model
+
+    Attributes:
+
+        model_type: str
+            type of gradient boosting algorithm: 'xgboost', 'lightgbm',
+            'catboost', 'gradientboosting'
+
+        n_estimators: int
+            maximum number of trees that can be built
+
+        learning_rate: float
+            shrinkage rate; used for reducing the gradient step
+
+        max_depth: int
+            maximum tree depth
+
+        rowsample: float
+            subsample ratio of the training instances
+
+        colsample: float
+            percentage of features to use at each node split
+
+        level: float
+            confidence level for prediction sets
+
+        pi_method: str
+            method for constructing the prediction intervals: 'splitconformal', 'localconformal'
+        
+        type_split: a string;
+            Only if `level` is not `None`
+            "random" (random split of data) or "sequential" (sequential split of data)
+
+        verbose: int
+            controls verbosity (default=0)
+
+        seed: int
+            reproducibility seed
+
+        **kwargs: dict
+            additional parameters to be passed to the class
+
+    Examples:
+
+        ```python
+        import unifiedbooster as ub
+        from sklearn.datasets import fetch_california_housing
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import mean_squared_error
+
+        # Load dataset
+        housing = fetch_california_housing()
+        X, y = housing.data, housing.target
+
+        # Split dataset into training and testing sets
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+        # Initialize the unified regressor (example with XGBoost)
+        regressor1 = ub.GBDTRegressor(model_type='xgboost')
+        #regressor2 = ub.GBDTRegressor(model_type='catboost')
+        regressor3 = ub.GBDTRegressor(model_type='lightgbm')
+
+        # Fit the model
+        regressor1.fit(X_train, y_train)
+        #regressor2.fit(X_train, y_train)
+        regressor3.fit(X_train, y_train)
+
+        # Predict on the test set
+        y_pred1 = regressor1.predict(X_test)
+        #y_pred2 = regressor2.predict(X_test)
+        y_pred3 = regressor3.predict(X_test)
+
+        # Evaluate the model
+        mse1 = mean_squared_error(y_test, y_pred1)
+        #mse2 = mean_squared_error(y_test, y_pred2)
+        mse3 = mean_squared_error(y_test, y_pred3)
+        print(f"Regression Mean Squared Error xgboost: {mse1:.2f}")
+        #print(f"Regression Mean Squared Error catboost: {mse2:.2f}")
+        print(f"Regression Mean Squared Error lightgbm: {mse3:.2f}")
+        ```
+    """
+
+    def __init__(
+        self,
+        model_type="xgboost",
+        n_estimators=100,
+        learning_rate=0.1,
+        max_depth=3,
+        rowsample=1.0,
+        colsample=1.0,
+        level=None,
+        pi_method="splitconformal",
+        type_split="random",
+        verbose=0,
+        seed=123,
+        **kwargs,
+    ):
+
+        self.type_fit = "regression"
+        self.type_split = type_split 
+
+        super().__init__(
+            model_type=model_type,
+            n_estimators=n_estimators,
+            learning_rate=learning_rate,
+            max_depth=max_depth,
+            rowsample=rowsample,
+            colsample=colsample,
+            level=level,
+            pi_method=pi_method,
+            verbose=verbose,
+            seed=seed,
+            **kwargs,
+        )
+
+        if self.level is not None:
+
+            if model_type in ("xgboost", "xgb"):
+                self.model = PredictionInterval(
+                    XGBRegressor(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                    type_split=self.type_split
+                )
+            elif model_type in ("catboost", "cb"):
+                self.model = PredictionInterval(
+                    CatBoostRegressor(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                    type_split=self.type_split
+                )
+            elif model_type in ("lightgbm", "lgb"):
+                self.model = PredictionInterval(
+                    LGBMRegressor(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                    type_split=self.type_split
+                )
+            elif model_type in ("gradientboosting", "gb"):
+                self.model = PredictionInterval(
+                    GradientBoostingRegressor(**self.params),
+                    level=self.level,
+                    method=self.pi_method,
+                    type_split=self.type_split
+                )
+            else:
+                raise ValueError(f"Unknown model_type: {model_type}")
+
+        else:
+
+            if model_type in ("xgboost", "xgb"):
+                self.model = XGBRegressor(**self.params)
+            elif model_type in ("catboost", "cb"):
+                self.model = CatBoostRegressor(**self.params)
+            elif model_type in ("lightgbm", "lgb"):
+                self.model = LGBMRegressor(**self.params)
+            elif model_type in ("gradientboosting", "gb"):
+                self.model = GradientBoostingRegressor(**self.params)
+            else:
+                raise ValueError(f"Unknown model_type: {model_type}")