unifiedbooster 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

unifiedbooster/__init__.py

@@ -1,5 +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"]
+__all__ = [
+    "GBDT",
+    "GBDTClassifier",
+    "GBDTRegressor",
+    "cross_val_optim",
+    "lazy_cross_val_optim",
+]

unifiedbooster/gbdt.py

@@ -17,6 +17,9 @@ class GBDT(BaseEstimator):
         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
 
@@ -87,6 +90,8 @@ class GBDT(BaseEstimator):
                 "depth": self.max_depth,
                 "verbose": self.verbose,
                 "random_seed": self.seed,
+                "boosting_type": "Plain",
+                "leaf_estimation_iterations": 1,                
                 "bootstrap_type": "Bernoulli",
                 **kwargs,
             }

unifiedbooster/gbdt_classification.py

@@ -1,12 +1,18 @@
 from .gbdt import GBDT
 from sklearn.base import ClassifierMixin
-from xgboost import XGBClassifier
 
+try:
+    from xgboost import XGBClassifier
+except:
+    pass
 try:
     from catboost import CatBoostClassifier
 except:
-    print("catboost package can't be built")
-from lightgbm import LGBMClassifier
+    pass
+try:
+    from lightgbm import LGBMClassifier
+except:
+    pass
 from sklearn.ensemble import GradientBoostingClassifier
 
 
@@ -25,6 +31,9 @@ class GBDTClassifier(GBDT, ClassifierMixin):
         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
 
@@ -42,42 +51,42 @@ class GBDTClassifier(GBDT, ClassifierMixin):
 
     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}")
-    ```
+        ```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__(

unifiedbooster/gbdt_regression.py

@@ -1,12 +1,18 @@
 from .gbdt import GBDT
 from sklearn.base import RegressorMixin
-from xgboost import XGBRegressor
 
+try:
+    from xgboost import XGBRegressor
+except:
+    pass
 try:
     from catboost import CatBoostRegressor
 except:
-    print("catboost package can't be built")
-from lightgbm import LGBMRegressor
+    pass
+try:
+    from lightgbm import LGBMRegressor
+except:
+    pass
 from sklearn.ensemble import GradientBoostingRegressor
 
 
@@ -25,6 +31,9 @@ class GBDTRegressor(GBDT, RegressorMixin):
         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
 
@@ -42,42 +51,42 @@ class GBDTRegressor(GBDT, RegressorMixin):
 
     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}")
-    ```
+        ```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__(

unifiedbooster/gpoptimization.py

@@ -0,0 +1,428 @@
+import GPopt as gp
+import nnetsauce as ns
+import numpy as np
+from collections import namedtuple
+from .gbdt_classification import GBDTClassifier
+from .gbdt_regression import GBDTRegressor
+from sklearn.model_selection import cross_val_score
+from sklearn.base import ClassifierMixin, RegressorMixin
+from sklearn.utils import all_estimators
+from sklearn import metrics
+
+
+def cross_val_optim(
+    X_train,
+    y_train,
+    X_test=None,
+    y_test=None,
+    model_type="xgboost",
+    type_fit="classification",
+    scoring="accuracy",
+    n_estimators=100,
+    surrogate_obj=None,
+    cv=5,
+    n_jobs=None,
+    n_init=10,
+    n_iter=190,
+    abs_tol=1e-3,
+    verbose=2,
+    seed=123,
+):
+    """Cross-validation function and hyperparameters' search
+
+    Parameters:
+
+        X_train: array-like,
+            Training vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        y_train: array-like,
+            Training vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        X_test: array-like,
+            Testing vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        y_test: array-like,
+            Testing vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        model_type: str
+            type of gradient boosting algorithm: 'xgboost', 'lightgbm',
+            'catboost', 'gradientboosting'
+
+        type_fit: str
+            "regression" or "classification"
+
+        scoring: str
+            scoring metric; see https://scikit-learn.org/stable/modules/model_evaluation.html#the-scoring-parameter-defining-model-evaluation-rules
+
+        n_estimators: int
+            maximum number of trees that can be built
+
+        surrogate_obj: an object;
+            An ML model for estimating the uncertainty around the objective function
+
+        cv: int;
+            number of cross-validation folds
+
+        n_jobs: int;
+            number of jobs for parallel execution
+
+        n_init: an integer;
+            number of points in the initial setting, when `x_init` and `y_init` are not provided
+
+        n_iter: an integer;
+            number of iterations of the minimization algorithm
+
+        abs_tol: a float;
+            tolerance for convergence of the optimizer (early stopping based on acquisition function)
+
+        verbose: int
+            controls verbosity
+
+        seed: int
+            reproducibility seed
+
+    Examples:
+
+        ```python
+        import unifiedbooster as ub
+        from sklearn.datasets import load_breast_cancer
+        from sklearn.model_selection import train_test_split
+
+        dataset = load_breast_cancer()
+        X, y = dataset.data, dataset.target
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42
+        )
+
+        res1 = ub.cross_val_optim(
+            X_train,
+            y_train,
+            X_test=None,
+            y_test=None,
+            model_type="lightgbm",
+            type_fit="classification",
+            scoring="accuracy",
+            n_estimators=100,
+            surrogate_obj=None,
+            cv=5,
+            n_jobs=None,
+            n_init=10,
+            n_iter=190,
+            abs_tol=1e-3,
+            verbose=2,
+            seed=123,
+        )
+        print(res1)
+        ```
+    """
+
+    def gbdt_cv(
+        X_train,
+        y_train,
+        model_type="xgboost",
+        n_estimators=100,
+        learning_rate=0.1,
+        max_depth=3,
+        rowsample=1.0,
+        colsample=1.0,
+        cv=5,
+        n_jobs=None,
+        type_fit="classification",
+        scoring="accuracy",
+        seed=123,
+    ):
+        if type_fit == "regression":
+            estimator = GBDTRegressor(
+                model_type=model_type,
+                n_estimators=n_estimators,
+                learning_rate=learning_rate,
+                max_depth=max_depth,
+                rowsample=rowsample,
+                colsample=colsample,
+                verbose=0,
+                seed=seed,
+            )
+        elif type_fit == "classification":
+            estimator = GBDTClassifier(
+                model_type=model_type,
+                n_estimators=n_estimators,
+                learning_rate=learning_rate,
+                max_depth=max_depth,
+                rowsample=rowsample,
+                colsample=colsample,
+                verbose=0,
+                seed=seed,
+            )
+        return -cross_val_score(
+            estimator,
+            X_train,
+            y_train,
+            scoring=scoring,
+            cv=cv,
+            n_jobs=n_jobs,
+            verbose=0,
+        ).mean()
+
+    # objective function for hyperparams tuning
+    def crossval_objective(xx):
+        return gbdt_cv(
+            X_train=X_train,
+            y_train=y_train,
+            model_type=model_type,
+            n_estimators=n_estimators,
+            learning_rate=10 ** xx[0],
+            max_depth=int(xx[1]),
+            rowsample=xx[2],
+            colsample=xx[3],
+            cv=cv,
+            n_jobs=n_jobs,
+            type_fit=type_fit,
+            scoring=scoring,
+            seed=seed,
+        )
+
+    if surrogate_obj is None:
+        gp_opt = gp.GPOpt(
+            objective_func=crossval_objective,
+            lower_bound=np.array([-6, 1, 0.5, 0.5]),
+            upper_bound=np.array([0, 16, 1.0, 1.0]),
+            params_names=[
+                "learning_rate",
+                "max_depth",
+                "rowsample",
+                "colsample",
+            ],
+            method="bayesian",
+            n_init=n_init,
+            n_iter=n_iter,
+            seed=seed,
+        )
+    else:
+        gp_opt = gp.GPOpt(
+            objective_func=crossval_objective,
+            lower_bound=np.array([-6, 1, 0.5, 0.5]),
+            upper_bound=np.array([0, 16, 1.0, 1.0]),
+            params_names=[
+                "learning_rate",
+                "max_depth",
+                "rowsample",
+                "colsample",
+            ],
+            acquisition="ucb",
+            method="splitconformal",
+            surrogate_obj=ns.PredictionInterval(
+                obj=surrogate_obj, method="splitconformal"
+            ),
+            n_init=n_init,
+            n_iter=n_iter,
+            seed=seed,
+        )
+
+    res = gp_opt.optimize(verbose=verbose, abs_tol=abs_tol)
+    res.best_params["model_type"] = model_type
+    res.best_params["n_estimators"] = int(n_estimators)
+    res.best_params["learning_rate"] = 10 ** res.best_params["learning_rate"]
+    res.best_params["max_depth"] = int(res.best_params["max_depth"])
+    res.best_params["rowsample"] = res.best_params["rowsample"]
+    res.best_params["colsample"] = res.best_params["colsample"]
+
+    # out-of-sample error
+    if X_test is not None and y_test is not None:
+        if type_fit == "regression":
+            estimator = GBDTRegressor(**res.best_params, verbose=0, seed=seed)
+        elif type_fit == "classification":
+            estimator = GBDTClassifier(**res.best_params, verbose=0, seed=seed)
+        preds = estimator.fit(X_train, y_train).predict(X_test)
+        # check error on y_test
+        oos_err = getattr(metrics, scoring + "_score")(
+            y_true=y_test, y_pred=preds
+        )
+        result = namedtuple("result", res._fields + ("test_" + scoring,))
+        return result(*res, oos_err)
+    else:
+        return res
+
+
+def lazy_cross_val_optim(
+    X_train,
+    y_train,
+    X_test=None,
+    y_test=None,
+    model_type="xgboost",
+    type_fit="classification",
+    scoring="accuracy",
+    customize=False,
+    n_estimators=100,
+    cv=5,
+    n_jobs=None,
+    n_init=10,
+    n_iter=190,
+    abs_tol=1e-3,
+    verbose=1,
+    seed=123,
+):
+    """Automated Cross-validation function and hyperparameters' search using multiple surrogates
+
+    Parameters:
+
+        X_train: array-like,
+            Training vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        y_train: array-like,
+            Training vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        X_test: array-like,
+            Testing vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        y_test: array-like,
+            Testing vectors, where rows is the number of samples
+            and columns is the number of features.
+
+        model_type: str
+            type of gradient boosting algorithm: 'xgboost', 'lightgbm',
+            'catboost', 'gradientboosting'
+
+        type_fit: str
+            "regression" or "classification"
+
+        scoring: str
+            scoring metric; see https://scikit-learn.org/stable/modules/model_evaluation.html#the-scoring-parameter-defining-model-evaluation-rules
+
+        customize: boolean
+            if True, the surrogate is transformed into a quasi-randomized network (default is False)
+            
+        n_estimators: int
+            maximum number of trees that can be built
+
+        cv: int;
+            number of cross-validation folds
+
+        n_jobs: int;
+            number of jobs for parallel execution
+
+        n_init: an integer;
+            number of points in the initial setting, when `x_init` and `y_init` are not provided
+
+        n_iter: an integer;
+            number of iterations of the minimization algorithm
+
+        abs_tol: a float;
+            tolerance for convergence of the optimizer (early stopping based on acquisition function)
+
+        verbose: int
+            controls verbosity
+
+        seed: int
+            reproducibility seed
+
+    Examples:
+
+        ```python
+        import os 
+        import unifiedbooster as ub
+        from sklearn.datasets import load_breast_cancer
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import accuracy_score
+        from time import time
+
+        print(f"\n ----- Running: {os.path.basename(__file__)}... ----- \n")
+
+        dataset = load_breast_cancer()
+        X, y = dataset.data, dataset.target
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42
+        )
+
+        start = time()
+        res4 = ub.lazy_cross_val_optim(
+            X_train,
+            y_train,
+            X_test=X_test,
+            y_test=y_test,
+            model_type="lightgbm",
+            type_fit="classification",
+            scoring="accuracy",
+            n_estimators=100,
+            cv=5,
+            n_jobs=None,
+            n_init=10,
+            n_iter=190,
+            abs_tol=1e-3,
+            seed=123,
+            customize=False
+        )
+        print(f"Elapsed: {time()-start}")
+        print(res4)
+        ```
+    """
+
+    removed_regressors = [
+        "TheilSenRegressor",
+        "ARDRegression",
+        "CCA",
+        "GaussianProcessRegressor",
+        "GradientBoostingRegressor",
+        "HistGradientBoostingRegressor",
+        "IsotonicRegression",
+        "MultiOutputRegressor",
+        "MultiTaskElasticNet",
+        "MultiTaskElasticNetCV",
+        "MultiTaskLasso",
+        "MultiTaskLassoCV",
+        "OrthogonalMatchingPursuit",
+        "OrthogonalMatchingPursuitCV",
+        "PLSCanonical",
+        "PLSRegression",
+        "RadiusNeighborsRegressor",
+        "RegressorChain",
+        "StackingRegressor",
+        "VotingRegressor",
+    ]
+
+    results = []
+
+    for est in all_estimators():
+        if issubclass(est[1], RegressorMixin) and (
+            est[0] not in removed_regressors
+        ):
+            try:
+                if customize == True:
+                    print(f"\n surrogate: CustomRegressor({est[0]})")
+                    surr_obj = ns.CustomRegressor(obj=est[1]())
+                else: 
+                    print(f"\n surrogate: {est[0]}")
+                    surr_obj = est[1]()
+                res = cross_val_optim(
+                    X_train=X_train,
+                    y_train=y_train,
+                    X_test=X_test,
+                    y_test=y_test,
+                    model_type=model_type,
+                    n_estimators=n_estimators,
+                    surrogate_obj=surr_obj,
+                    cv=cv,
+                    n_jobs=n_jobs,
+                    type_fit=type_fit,
+                    scoring=scoring,
+                    n_init=n_init,
+                    n_iter=n_iter,
+                    abs_tol=abs_tol,
+                    verbose=verbose,
+                    seed=seed,
+                )
+                print(f"\n result: {res}")
+                if customize == True:
+                    results.append((f"CustomRegressor({est[0]})", res))
+                else:
+                    results.append((est[0], res))                     
+            except:
+                pass
+
+    return results

{unifiedbooster-0.3.0.dist-info → unifiedbooster-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unifiedbooster
-Version: 0.3.0
+Version: 0.5.0
 Summary: Unified interface for Gradient Boosted Decision Trees
 Home-page: https://github.com/thierrymoudiki/unifiedbooster
 Author: T. Moudiki
@@ -24,5 +24,6 @@ Requires-Dist: xgboost
 Requires-Dist: lightgbm
 Requires-Dist: catboost
 Requires-Dist: GPopt
+Requires-Dist: nnetsauce
 
 Unified interface for Gradient Boosted Decision Trees

unifiedbooster-0.5.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+unifiedbooster/__init__.py,sha256=8FEkWCZ2tT8xcW46Z0X_BS9_r0kQWVAu37IncLq6QWU,301
+unifiedbooster/gbdt.py,sha256=u5Sjw-V8BlDS4LUo_SNOfuz66EFcJhP1Al6Es41R_X8,4932
+unifiedbooster/gbdt_classification.py,sha256=wifw86cUvsyiKSz8MTxIgH6j7Gd1voIxXUiJVsE68bk,4219
+unifiedbooster/gbdt_regression.py,sha256=YQIDtW4hV7DxHAHuoMMkD1aRy0dzVXxx2rwPu3InTA8,3710
+unifiedbooster/gpoptimization.py,sha256=S-yZI8qI_QZyoCqWj8MT0a2Djlo3YrYRjyXApLS9FXM,12831
+unifiedbooster-0.5.0.dist-info/LICENSE,sha256=3rWw63btcdqbC0XMnpzCQhxDP8Vx7yKkKS7EDgJiY_4,1061
+unifiedbooster-0.5.0.dist-info/METADATA,sha256=mao-q4w_f26KVwKSy4ZPEJBZQIRARtXsWEN7t7JEwRw,955
+unifiedbooster-0.5.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+unifiedbooster-0.5.0.dist-info/entry_points.txt,sha256=OVNTsCzMYnaJ11WIByB7G8Lym_dj-ERKZyQxWFUcW30,59
+unifiedbooster-0.5.0.dist-info/top_level.txt,sha256=gOMxxpRtx8_nJXTWsXJDFkNeCsjSJQPs6aUXKK5_nI4,15
+unifiedbooster-0.5.0.dist-info/RECORD,,

unifiedbooster-0.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-unifiedbooster/__init__.py,sha256=3d8wQVXaeVIxqtk_STM6nvIGZiGTxKn9aAWjuwiDYuo,169
-unifiedbooster/gbdt.py,sha256=QCcWfXYfrOXdiSeygPEvVMjg9fVNjRaOnW9KsHK6bvo,4770
-unifiedbooster/gbdt_classification.py,sha256=UqZEOjDp_2hSm4jCxVoqz8vNQ-8JRW4Xn5CjFqPqRF4,4028
-unifiedbooster/gbdt_regression.py,sha256=ZNX5RJF-Wk2KJpOUD-lgNnqruDHZpzSTxdKeayv6iw0,3519
-unifiedbooster-0.3.0.dist-info/LICENSE,sha256=3rWw63btcdqbC0XMnpzCQhxDP8Vx7yKkKS7EDgJiY_4,1061
-unifiedbooster-0.3.0.dist-info/METADATA,sha256=E0drgIWtoGZNF1lkxrj_zlbMxq8QmOPIW4iDY_GPKm0,930
-unifiedbooster-0.3.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-unifiedbooster-0.3.0.dist-info/entry_points.txt,sha256=OVNTsCzMYnaJ11WIByB7G8Lym_dj-ERKZyQxWFUcW30,59
-unifiedbooster-0.3.0.dist-info/top_level.txt,sha256=gOMxxpRtx8_nJXTWsXJDFkNeCsjSJQPs6aUXKK5_nI4,15
-unifiedbooster-0.3.0.dist-info/RECORD,,