unifiedbooster 0.7.0__tar.gz → 0.9.0__tar.gz

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unifiedbooster
-Version: 0.7.0
+Version: 0.9.0
 Summary: Unified interface for Gradient Boosted Decision Trees
 Home-page: https://github.com/thierrymoudiki/unifiedbooster
 Author: T. Moudiki
@@ -22,8 +22,18 @@ Requires-Dist: numpy
 Requires-Dist: scikit-learn
 Requires-Dist: xgboost
 Requires-Dist: lightgbm
-Requires-Dist: catboost
 Requires-Dist: GPopt
 Requires-Dist: nnetsauce
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Unified interface for Gradient Boosted Decision Trees

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/README.md

@@ -7,7 +7,10 @@ Unified interface for Gradient Boosted Decision Trees algorithms
 
 ## Examples 
 
-See also https://thierrymoudiki.github.io/blog/2024/08/05/python/r/unibooster
+See also: 
+- Auto XGBoost, Auto LightGBM, Auto CatBoost, Auto GradientBoosting: https://thierrymoudiki.github.io/blog/2024/08/05/python/r/unibooster
+- Prediction sets and prediction intervals for conformalized Auto XGBoost, Auto LightGBM, Auto CatBoost, Auto GradientBoosting: https://thierrymoudiki.github.io/blog/2024/09/02/python/r/conformalized-unibooster
+- Notebooks in [/unifiedbooster/demo](/unifiedbooster/demo)
 
 ### classification 
 

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/setup.py

@@ -7,9 +7,7 @@ from setuptools import setup, find_packages
 from codecs import open
 from os import path
 
-subprocess.check_call(['pip', 'install', 'Cython'])
-
-__version__ = "0.7.0"
+__version__ = "0.9.0"
 
 here = path.abspath(path.dirname(__file__))
 

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/gbdt.py

@@ -35,6 +35,7 @@ class GBDT(BaseEstimator):
         **kwargs: dict
             additional parameters to be passed to the class
     """
+
     def __init__(
         self,
         model_type="xgboost",

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/gbdt_classification.py

@@ -40,10 +40,10 @@ class GBDTClassifier(GBDT, ClassifierMixin):
 
         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)
 
@@ -95,6 +95,7 @@ class GBDTClassifier(GBDT, ClassifierMixin):
         print(f"Classification Accuracy lightgbm: {accuracy3:.2f}")
         ```
     """
+
     def __init__(
         self,
         model_type="xgboost",
@@ -128,34 +129,42 @@ class GBDTClassifier(GBDT, ClassifierMixin):
 
         if self.level is not None:
 
-            if model_type == "xgboost":
-                self.model = PredictionSet(XGBClassifier(**self.params), 
-                                            level=self.level, 
-                                            method=self.pi_method)
-            elif model_type == "catboost":
-                self.model = PredictionSet(CatBoostClassifier(**self.params), 
-                                            level=self.level, 
-                                            method=self.pi_method)
-            elif model_type == "lightgbm":
-                self.model = PredictionSet(LGBMClassifier(**self.params), 
-                                            level=self.level, 
-                                            method=self.pi_method)
-            elif model_type == "gradientboosting":
-                self.model = PredictionSet(GradientBoostingClassifier(**self.params), 
-                                            level=self.level, 
-                                            method=self.pi_method)
+            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 == "xgboost":
+            if model_type in ("xgboost", "xgb"):
                 self.model = XGBClassifier(**self.params)
-            elif model_type == "catboost":
+            elif model_type in ("catboost", "cb"):
                 self.model = CatBoostClassifier(**self.params)
-            elif model_type == "lightgbm":
+            elif model_type in ("lightgbm", "lgb"):
                 self.model = LGBMClassifier(**self.params)
-            elif model_type == "gradientboosting":
+            elif model_type in ("gradientboosting", "gb"):
                 self.model = GradientBoostingClassifier(**self.params)
             else:
                 raise ValueError(f"Unknown model_type: {model_type}")

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/gbdt_regression.py

@@ -40,12 +40,16 @@ class GBDTRegressor(GBDT, RegressorMixin):
 
         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)
@@ -95,6 +99,7 @@ class GBDTRegressor(GBDT, RegressorMixin):
         print(f"Regression Mean Squared Error lightgbm: {mse3:.2f}")
         ```
     """
+
     def __init__(
         self,
         model_type="xgboost",
@@ -105,12 +110,14 @@ class GBDTRegressor(GBDT, RegressorMixin):
         colsample=1.0,
         level=None,
         pi_method="splitconformal",
+        type_split="random",
         verbose=0,
         seed=123,
         **kwargs,
     ):
 
-        self.type_fit = "regression"        
+        self.type_fit = "regression"
+        self.type_split = type_split 
 
         super().__init__(
             model_type=model_type,
@@ -128,34 +135,46 @@ class GBDTRegressor(GBDT, RegressorMixin):
 
         if self.level is not None:
 
-            if model_type == "xgboost":
-                self.model = PredictionInterval(XGBRegressor(**self.params), 
-                                                level=self.level, 
-                                                method=self.pi_method)
-            elif model_type == "catboost":
-                self.model = PredictionInterval(CatBoostRegressor(**self.params), 
-                                                level=self.level, 
-                                                method=self.pi_method)
-            elif model_type == "lightgbm":
-                self.model = PredictionInterval(LGBMRegressor(**self.params), 
-                                                level=self.level, 
-                                                method=self.pi_method)
-            elif model_type == "gradientboosting":
-                self.model = PredictionInterval(GradientBoostingRegressor(**self.params), 
-                                                level=self.level, 
-                                                method=self.pi_method)
+            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 == "xgboost":
+
+        else:
+
+            if model_type in ("xgboost", "xgb"):
                 self.model = XGBRegressor(**self.params)
-            elif model_type == "catboost":
+            elif model_type in ("catboost", "cb"):
                 self.model = CatBoostRegressor(**self.params)
-            elif model_type == "lightgbm":
+            elif model_type in ("lightgbm", "lgb"):
                 self.model = LGBMRegressor(**self.params)
-            elif model_type == "gradientboosting":
+            elif model_type in ("gradientboosting", "gb"):
                 self.model = GradientBoostingRegressor(**self.params)
             else:
                 raise ValueError(f"Unknown model_type: {model_type}")

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/nonconformist/__init__.py

@@ -28,9 +28,9 @@ __all__ = [
     "RegressorAdapter",
     "ClassifierAdapter",
     "RegressorNc",
-    "ClassifierNc", 
+    "ClassifierNc",
     "RegressorNormalizer",
     "IcpRegressor",
     "IcpClassifier",
-    "TcpClassifier"
+    "TcpClassifier",
 ]

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/nonconformist/base.py

@@ -108,7 +108,7 @@ class ClassifierAdapter(BaseModelAdapter, ClassifierMixin):
 
     def _underlying_predict(self, x):
         return self.model.predict_proba(x)
-    
+
 
 class RegressorAdapter(BaseModelAdapter, RegressorMixin):
     def __init__(self, model, fit_params=None):

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster/predictionset/predictionset.py

@@ -8,7 +8,13 @@ from sklearn.ensemble import ExtraTreesRegressor
 from sklearn.preprocessing import StandardScaler
 from scipy.stats import gaussian_kde
 from tqdm import tqdm
-from ..nonconformist import ClassifierAdapter, IcpClassifier, TcpClassifier, ClassifierNc, MarginErrFunc
+from ..nonconformist import (
+    ClassifierAdapter,
+    IcpClassifier,
+    TcpClassifier,
+    ClassifierNc,
+    MarginErrFunc,
+)
 
 
 class PredictionSet(BaseEstimator, ClassifierMixin):
@@ -47,21 +53,18 @@ class PredictionSet(BaseEstimator, ClassifierMixin):
             self.alpha_ = 1 - self.level / 100
         self.quantile_ = None
         self.icp_ = None
-        self.tcp_ = None        
+        self.tcp_ = None
 
         if self.method == "icp":
-            self.icp_ = IcpClassifier(                
+            self.icp_ = IcpClassifier(
                 ClassifierNc(ClassifierAdapter(self.obj), MarginErrFunc()),
             )
         elif self.method == "tcp":
-            self.tcp_ = TcpClassifier(                
+            self.tcp_ = TcpClassifier(
                 ClassifierNc(ClassifierAdapter(self.obj), MarginErrFunc()),
-            )            
-        else:
-            raise ValueError(
-                "`self.method` must be in ('icp', 'tcp')"
             )
-           
+        else:
+            raise ValueError("`self.method` must be in ('icp', 'tcp')")
 
     def fit(self, X, y):
         """Fit the `method` to training data (X, y).
@@ -74,13 +77,14 @@ class PredictionSet(BaseEstimator, ClassifierMixin):
 
             y: array-like, shape = [n_samples, ]; Target values.
 
-        """        
+        """
         if self.method == "icp":
 
             X_train, X_calibration, y_train, y_calibration = train_test_split(
-            X, y, test_size=0.5, random_state=self.seed)
+                X, y, test_size=0.5, random_state=self.seed
+            )
             self.icp_.fit(X_train, y_train)
-            self.icp_.calibrate(X_calibration, y_calibration)  
+            self.icp_.calibrate(X_calibration, y_calibration)
 
         elif self.method == "tcp":
 
@@ -101,11 +105,9 @@ class PredictionSet(BaseEstimator, ClassifierMixin):
 
         if self.method == "icp":
             return self.icp_.predict(X, significance=self.alpha_)
-        
+
         elif self.method == "tcp":
             return self.tcp_.predict(X, significance=self.alpha_)
-        
+
         else:
-            raise ValueError(
-                "`self.method` must be in ('icp', 'tcp')"
-            )
+            raise ValueError("`self.method` must be in ('icp', 'tcp')")

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unifiedbooster
-Version: 0.7.0
+Version: 0.9.0
 Summary: Unified interface for Gradient Boosted Decision Trees
 Home-page: https://github.com/thierrymoudiki/unifiedbooster
 Author: T. Moudiki
@@ -22,8 +22,18 @@ Requires-Dist: numpy
 Requires-Dist: scikit-learn
 Requires-Dist: xgboost
 Requires-Dist: lightgbm
-Requires-Dist: catboost
 Requires-Dist: GPopt
 Requires-Dist: nnetsauce
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Unified interface for Gradient Boosted Decision Trees

{unifiedbooster-0.7.0 → unifiedbooster-0.9.0}/unifiedbooster.egg-info/requires.txt

@@ -3,6 +3,5 @@ numpy
 scikit-learn
 xgboost
 lightgbm
-catboost
 GPopt
 nnetsauce