mlsauce

 19class AdaOpt(BaseEstimator, ClassifierMixin):
 20    """AdaOpt classifier.
 21
 22    Attributes:
 23
 24        n_iterations: int
 25            number of iterations of the optimizer at training time.
 26
 27        learning_rate: float
 28            controls the speed of the optimizer at training time.
 29
 30        reg_lambda: float
 31            L2 regularization parameter for successive errors in the optimizer
 32            (at training time).
 33
 34        reg_alpha: float
 35            L1 regularization parameter for successive errors in the optimizer
 36            (at training time).
 37
 38        eta: float
 39            controls the slope in gradient descent (at training time).
 40
 41        gamma: float
 42            controls the step size in gradient descent (at training time).
 43
 44        k: int
 45            number of nearest neighbors selected at test time for classification.
 46
 47        tolerance: float
 48            controls early stopping in gradient descent (at training time).
 49
 50        n_clusters: int
 51            number of clusters, if MiniBatch k-means is used at test time
 52            (for faster prediction).
 53
 54        batch_size: int
 55            size of the batch, if MiniBatch k-means is used at test time
 56            (for faster prediction).
 57
 58        row_sample: float
 59            percentage of rows chosen from training set (by stratified subsampling,
 60            for faster prediction).
 61
 62        type_dist: str
 63            distance used for finding the nearest neighbors; currently `euclidean-f`
 64            (euclidean distances calculated as whole), `euclidean` (euclidean distances
 65            calculated row by row), `cosine` (cosine distance).
 66
 67        n_jobs: int
 68            number of cpus for parallel processing (default: None)
 69
 70        verbose: int
 71            progress bar for parallel processing (yes = 1) or not (no = 0)
 72
 73        cache: boolean
 74            if the nearest neighbors are cached or not, for faster retrieval in
 75            subsequent calls.
 76
 77        n_clusters_input: int
 78            number of clusters (a priori) for clustering the features
 79
 80        clustering_method: str
 81            clustering method: currently 'kmeans', 'gmm'
 82
 83        cluster_scaling: str
 84            scaling method for clustering: currently 'standard', 'robust', 'minmax'
 85
 86        seed: int
 87            reproducibility seed for nodes_sim=='uniform', clustering and dropout.
 88
 89    """
 90
 91    def __init__(
 92        self,
 93        n_iterations=50,
 94        learning_rate=0.3,
 95        reg_lambda=0.1,
 96        reg_alpha=0.5,
 97        eta=0.01,
 98        gamma=0.01,
 99        k=3,
100        tolerance=0,
101        n_clusters=0,
102        batch_size=100,
103        row_sample=0.8,
104        type_dist="euclidean-f",
105        n_jobs=None,
106        verbose=0,
107        cache=True,
108        n_clusters_input=0,
109        clustering_method="kmeans",
110        cluster_scaling="standard",
111        seed=123,
112    ):
113        if n_clusters_input > 0:
114            assert clustering_method in (
115                "kmeans",
116                "gmm",
117            ), "`clustering_method` must be in ('kmeans', 'gmm')"
118            assert cluster_scaling in (
119                "standard",
120                "robust",
121                "minmax",
122            ), "`cluster_scaling` must be in ('standard', 'robust', 'minmax')"
123
124        assert type_dist in (
125            "euclidean",
126            "manhattan",
127            "euclidean-f",
128            "cosine",
129        ), "must have: `type_dist` in ('euclidean', 'manhattan', 'euclidean-f', 'cosine') "
130
131        self.n_iterations = n_iterations
132        self.learning_rate = learning_rate
133        self.reg_lambda = reg_lambda
134        self.reg_alpha = reg_alpha
135        self.eta = eta
136        self.gamma = gamma
137        self.k = k
138        self.tolerance = tolerance
139        self.n_clusters = n_clusters
140        self.batch_size = batch_size
141        self.row_sample = row_sample
142        self.type_dist = type_dist
143        self.n_jobs = n_jobs
144        self.cache = cache
145        self.verbose = verbose
146        self.n_clusters_input = n_clusters_input
147        self.clustering_method = clustering_method
148        self.cluster_scaling = cluster_scaling
149        self.scaler_, self.label_encoder_, self.clusterer_ = None, None, None
150        self.seed = seed
151
152    def fit(self, X, y, **kwargs):
153        """Fit AdaOpt to training data (X, y)
154
155        Args:
156
157            X: {array-like}, shape = [n_samples, n_features]
158                Training vectors, where n_samples is the number
159                of samples and n_features is the number of features.
160
161            y: array-like, shape = [n_samples]
162                Target values.
163
164            **kwargs: additional parameters to be passed to self.cook_training_set.
165
166        Returns:
167
168            self: object.
169
170        """
171
172        if self.n_clusters_input > 0:
173            clustered_X, self.scaler_, self.label_encoder_, self.clusterer_ = (
174                cluster(
175                    X,
176                    n_clusters=self.n_clusters_input,
177                    method=self.clustering_method,
178                    type_scaling=self.cluster_scaling,
179                    training=True,
180                    seed=self.seed,
181                )
182            )
183            X = np.column_stack((X.copy(), clustered_X))
184
185        if self.row_sample < 1:
186            index_subsample = subsample(
187                y, row_sample=self.row_sample, seed=self.seed
188            )
189            y_ = y[index_subsample]
190            X_ = X[index_subsample, :]
191        else:
192            y_ = pickle.loads(pickle.dumps(y, -1))
193            X_ = pickle.loads(pickle.dumps(X, -1))
194
195        n, p = X_.shape
196
197        n_classes = len(np.unique(y_))
198
199        assert n == len(y_), "must have X.shape[0] == len(y)"
200
201        res = adaoptc.fit_adaopt(
202            X=np.asarray(X_).astype(np.float64),
203            y=np.asarray(y_).astype(np.int64),
204            n_iterations=self.n_iterations,
205            n_X=n,
206            p_X=p,
207            n_classes=n_classes,
208            learning_rate=self.learning_rate,
209            reg_lambda=self.reg_lambda,
210            reg_alpha=self.reg_alpha,
211            eta=self.eta,
212            gamma=self.gamma,
213            tolerance=self.tolerance,
214        )
215
216        self.probs_training = res["probs"]
217        self.training_accuracy = res["training_accuracy"]
218        self.alphas = res["alphas"]
219        self.n_iterations = res["n_iterations"]
220        self.scaled_X_train = np.array(res["scaled_X_train"], dtype=np.float64)
221        self.n_classes_ = len(np.unique(y))  # for compatibility with sklearn
222        return self
223
224    def predict(self, X, **kwargs):
225        """Predict test data X.
226
227        Args:
228
229            X: {array-like}, shape = [n_samples, n_features]
230                Training vectors, where n_samples is the number
231                of samples and n_features is the number of features.
232
233            **kwargs: additional parameters to be passed to `predict_proba`
234
235        Returns:
236
237            model predictions: {array-like}
238
239        """
240
241        return np.argmax(self.predict_proba(X, **kwargs), axis=1)
242
243    def predict_proba(self, X, **kwargs):
244        """Predict probabilities for test data X.
245
246        Args:
247
248            X: {array-like}, shape = [n_samples, n_features]
249                Training vectors, where n_samples is the number
250                of samples and n_features is the number of features.
251
252            **kwargs: additional parameters to be passed to
253                self.cook_test_set
254
255        Returns:
256
257            probability estimates for test data: {array-like}
258
259        """
260
261        n_train, p_train = self.scaled_X_train.shape
262
263        if self.n_clusters_input > 0:
264            X = np.column_stack(
265                (
266                    X.copy(),
267                    cluster(
268                        X,
269                        training=False,
270                        scaler=self.scaler_,
271                        label_encoder=self.label_encoder_,
272                        clusterer=self.clusterer_,
273                        seed=self.seed,
274                    ),
275                )
276            )
277
278        n_test = X.shape[0]
279
280        if self.n_jobs is None:
281            return adaoptc.predict_proba_adaopt(
282                X_test=np.asarray(X, order="C").astype(np.float64),
283                scaled_X_train=np.asarray(
284                    self.scaled_X_train, order="C"
285                ).astype(np.float64),
286                n_test=n_test,
287                n_train=n_train,
288                probs_train=self.probs_training,
289                k=self.k,
290                n_clusters=self.n_clusters,
291                batch_size=self.batch_size,
292                type_dist=self.type_dist,
293                cache=self.cache,
294                seed=self.seed,
295            )
296
297        # parallel: self.n_jobs is not None
298        assert self.type_dist in (
299            "euclidean",
300            "manhattan",
301            "cosine",
302        ), "must have: `self.type_dist` in ('euclidean', 'manhattan', 'cosine') "
303
304        scaled_X_test = X / norm(X, ord=2, axis=1)[:, None]
305
306        if self.type_dist == "euclidean":
307
308            @delayed
309            @wrap_non_picklable_objects
310            def multiproc_func(i):
311                dists_test_i = adaoptc.distance_to_mat_euclidean2(
312                    np.asarray(scaled_X_test.astype(np.float64), order="C")[
313                        i, :
314                    ],
315                    np.asarray(
316                        self.scaled_X_train.astype(np.float64), order="C"
317                    ),
318                    np.zeros(n_train),
319                    n_train,
320                    p_train,
321                )
322
323                kmin_test_i = adaoptc.find_kmin_x(
324                    dists_test_i, n_x=n_train, k=self.k, cache=self.cache
325                )
326
327                weights_test_i = adaoptc.calculate_weights(kmin_test_i[0])
328
329                probs_test_i = adaoptc.calculate_probs(
330                    kmin_test_i[1], self.probs_training
331                )
332
333                return adaoptc.average_probs(
334                    probs=probs_test_i, weights=weights_test_i
335                )
336
337        if self.type_dist == "manhattan":
338
339            @delayed
340            @wrap_non_picklable_objects
341            def multiproc_func(i):
342                dists_test_i = adaoptc.distance_to_mat_manhattan2(
343                    np.asarray(scaled_X_test.astype(np.float64), order="C")[
344                        i, :
345                    ],
346                    np.asarray(
347                        self.scaled_X_train.astype(np.float64), order="C"
348                    ),
349                    np.zeros(n_train),
350                    n_train,
351                    p_train,
352                )
353
354                kmin_test_i = adaoptc.find_kmin_x(
355                    dists_test_i, n_x=n_train, k=self.k, cache=self.cache
356                )
357
358                weights_test_i = adaoptc.calculate_weights(kmin_test_i[0])
359
360                probs_test_i = adaoptc.calculate_probs(
361                    kmin_test_i[1], self.probs_training
362                )
363
364                return adaoptc.average_probs(
365                    probs=probs_test_i, weights=weights_test_i
366                )
367
368        if self.type_dist == "cosine":
369
370            @delayed
371            @wrap_non_picklable_objects
372            def multiproc_func(i, *args):
373                dists_test_i = adaoptc.distance_to_mat_cosine2(
374                    np.asarray(scaled_X_test.astype(np.float64), order="C")[
375                        i, :
376                    ],
377                    np.asarray(
378                        self.scaled_X_train.astype(np.float64), order="C"
379                    ),
380                    np.zeros(n_train),
381                    n_train,
382                    p_train,
383                )
384
385                kmin_test_i = adaoptc.find_kmin_x(
386                    dists_test_i, n_x=n_train, k=self.k, cache=self.cache
387                )
388
389                weights_test_i = adaoptc.calculate_weights(kmin_test_i[0])
390
391                probs_test_i = adaoptc.calculate_probs(
392                    kmin_test_i[1], self.probs_training
393                )
394
395                return adaoptc.average_probs(
396                    probs=probs_test_i, weights=weights_test_i
397                )
398
399        if self.verbose == 1:
400            res = Parallel(n_jobs=self.n_jobs, prefer="threads")(
401                (multiproc_func)(m) for m in tqdm(range(n_test))
402            )
403
404        else:
405            res = Parallel(n_jobs=self.n_jobs, prefer="threads")(
406                (multiproc_func)(m) for m in range(n_test)
407            )
408
409        return np.asarray(res)

 18class LSBoostClassifier(BaseEstimator, ClassifierMixin):
 19    """LSBoost classifier.
 20
 21    Attributes:
 22
 23        n_estimators: int
 24            number of boosting iterations.
 25
 26        learning_rate: float
 27            controls the learning speed at training time.
 28
 29        n_hidden_features: int
 30            number of nodes in successive hidden layers.
 31
 32        reg_lambda: float
 33            L2 regularization parameter for successive errors in the optimizer
 34            (at training time).
 35
 36        alpha: float
 37            compromise between L1 and L2 regularization (must be in [0, 1]),
 38            for `solver` == 'enet'.
 39
 40        row_sample: float
 41            percentage of rows chosen from the training set.
 42
 43        col_sample: float
 44            percentage of columns chosen from the training set.
 45
 46        dropout: float
 47            percentage of nodes dropped from the training set.
 48
 49        tolerance: float
 50            controls early stopping in gradient descent (at training time).
 51
 52        direct_link: bool
 53            indicates whether the original features are included (True) in model's
 54            fitting or not (False).
 55
 56        verbose: int
 57            progress bar (yes = 1) or not (no = 0) (currently).
 58
 59        seed: int
 60            reproducibility seed for nodes_sim=='uniform', clustering and dropout.
 61
 62        backend: str
 63            type of backend; must be in ('cpu', 'gpu', 'tpu')
 64
 65        solver: str
 66            type of 'weak' learner; currently in ('ridge', 'lasso', 'enet').
 67            'enet' is a combination of 'ridge' and 'lasso' called Elastic Net.
 68
 69        activation: str
 70            activation function: currently 'relu', 'relu6', 'sigmoid', 'tanh'
 71
 72        n_clusters: int
 73            number of clusters for clustering the features
 74
 75        clustering_method: str
 76            clustering method: currently 'kmeans', 'gmm'
 77
 78        cluster_scaling: str
 79            scaling method for clustering: currently 'standard', 'robust', 'minmax'
 80
 81        degree: int
 82            degree of features interactions to include in the model
 83
 84        weights_distr: str
 85            distribution of weights for constructing the model's hidden layer;
 86            currently 'uniform', 'gaussian'
 87
 88        hist: bool
 89            indicates whether histogram features are used or not (default is False)
 90
 91        bins: int or str
 92            number of bins for histogram features (same as numpy.histogram, default is 'auto')
 93
 94    Examples:
 95
 96        ```python
 97        import numpy as np
 98        from sklearn.datasets import load_digits, load_breast_cancer, load_wine, load_iris
 99        from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
100        from sklearn.tree import DecisionTreeRegressor
101        from sklearn.kernel_ridge import KernelRidge
102        from time import time
103        from os import chdir
104        from sklearn import metrics
105        import os
106
107        import mlsauce as ms
108
109        print("\n")
110        print("GenericBoosting Decision tree -----")
111        print("\n")
112
113        print("\n")
114        print("breast_cancer data -----")
115
116        # data 1
117        breast_cancer = load_breast_cancer()
118        X = breast_cancer.data
119        y = breast_cancer.target
120        # split data into training test and test set
121        np.random.seed(15029)
122        X_train, X_test, y_train, y_test = train_test_split(X, y,
123                                                            test_size=0.2)
124
125        clf = DecisionTreeRegressor()
126        clf2 = KernelRidge()
127
128        obj = ms.GenericBoostingClassifier(clf, tolerance=1e-2)
129        print(obj.get_params())
130        start = time()
131        obj.fit(X_train, y_train)
132        print(time()-start)
133        start = time()
134        print(obj.score(X_test, y_test))
135        print(time()-start)
136
137        print(obj.obj['loss'])
138
139        obj = ms.GenericBoostingClassifier(clf, tolerance=1e-2, n_clusters=2)
140        print(obj.get_params())
141        start = time()
142        obj.fit(X_train, y_train)
143        print(time()-start)
144        start = time()
145        print(obj.score(X_test, y_test))
146        print(time()-start)
147
148        print(obj.obj['loss'])
149
150
151        # data 2
152        print("\n")
153        print("wine data -----")
154
155        wine = load_wine()
156        Z = wine.data
157        t = wine.target
158        np.random.seed(879423)
159        X_train, X_test, y_train, y_test = train_test_split(Z, t,
160                                                            test_size=0.2)
161
162        obj = ms.GenericBoostingClassifier(clf)
163        print(obj.get_params())
164        start = time()
165        obj.fit(X_train, y_train)
166        print(time()-start)
167        start = time()
168        print(obj.score(X_test, y_test))
169        print(time()-start)
170
171        print(obj.obj['loss'])
172
173        obj = ms.GenericBoostingClassifier(clf, n_clusters=3)
174        print(obj.get_params())
175        start = time()
176        obj.fit(X_train, y_train)
177        print(time()-start)
178        start = time()
179        print(obj.score(X_test, y_test))
180        print(time()-start)
181
182        print(obj.obj['loss'])
183
184        # data 3
185        print("\n")
186        print("iris data -----")
187
188        iris = load_iris()
189        Z = iris.data
190        t = iris.target
191        np.random.seed(734563)
192        X_train, X_test, y_train, y_test = train_test_split(Z, t,
193                                                            test_size=0.2)
194
195
196        obj = ms.GenericBoostingClassifier(clf)
197        print(obj.get_params())
198        start = time()
199        obj.fit(X_train, y_train)
200        print(time()-start)
201        start = time()
202        print(obj.score(X_test, y_test))
203        print(time()-start)
204
205        print(obj.obj['loss'])
206
207
208        print("\n")
209        print("GenericBoosting  KRR -----")
210        print("\n")
211
212        obj = ms.GenericBoostingClassifier(clf2, tolerance=1e-2)
213        print(obj.get_params())
214        start = time()
215        obj.fit(X_train, y_train)
216        print(time()-start)
217        start = time()
218        print(obj.score(X_test, y_test))
219        print(time()-start)
220
221        print(obj.obj['loss'])
222
223        obj = ms.GenericBoostingClassifier(clf2, tolerance=1e-2, n_clusters=2)
224        print(obj.get_params())
225        start = time()
226        obj.fit(X_train, y_train)
227        print(time()-start)
228        start = time()
229        print(obj.score(X_test, y_test))
230        print(time()-start)
231
232        print(obj.obj['loss'])
233
234
235        # data 2
236        print("\n")
237        print("wine data -----")
238
239        wine = load_wine()
240        Z = wine.data
241        t = wine.target
242        np.random.seed(879423)
243        X_train, X_test, y_train, y_test = train_test_split(Z, t,
244                                                            test_size=0.2)
245
246        obj = ms.GenericBoostingClassifier(clf2)
247        print(obj.get_params())
248        start = time()
249        obj.fit(X_train, y_train)
250        print(time()-start)
251        start = time()
252        print(obj.score(X_test, y_test))
253        print(time()-start)
254
255        print(obj.obj['loss'])
256
257        obj = ms.GenericBoostingClassifier(clf2, n_clusters=3)
258        print(obj.get_params())
259        start = time()
260        obj.fit(X_train, y_train)
261        print(time()-start)
262        start = time()
263        print(obj.score(X_test, y_test))
264        print(time()-start)
265
266        print(obj.obj['loss'])
267
268        # data 3
269        print("\n")
270        print("iris data -----")
271
272        iris = load_iris()
273        Z = iris.data
274        t = iris.target
275        np.random.seed(734563)
276        X_train, X_test, y_train, y_test = train_test_split(Z, t,
277                                                            test_size=0.2)
278
279
280        obj = ms.GenericBoostingClassifier(clf2)
281        print(obj.get_params())
282        start = time()
283        obj.fit(X_train, y_train)
284        print(time()-start)
285        start = time()
286        print(obj.score(X_test, y_test))
287        print(time()-start)
288
289        print(obj.obj['loss'])
290    ```
291
292    """
293
294    def __init__(
295        self,
296        n_estimators=100,
297        learning_rate=0.1,
298        n_hidden_features=5,
299        reg_lambda=0.1,
300        alpha=0.5,
301        row_sample=1,
302        col_sample=1,
303        dropout=0,
304        tolerance=1e-4,
305        direct_link=1,
306        verbose=1,
307        seed=123,
308        backend="cpu",
309        solver="ridge",
310        activation="relu",
311        n_clusters=0,
312        clustering_method="kmeans",
313        cluster_scaling="standard",
314        degree=None,
315        weights_distr="uniform",
316        base_model=None,
317        hist=False,
318        bins="auto",
319    ):
320
321        self.base_model = base_model
322        self.hist = hist
323        self.bins = bins
324        self.hist_bins_ = None
325
326        if n_clusters > 0:
327            assert clustering_method in (
328                "kmeans",
329                "gmm",
330            ), "`clustering_method` must be in ('kmeans', 'gmm')"
331            assert cluster_scaling in (
332                "standard",
333                "robust",
334                "minmax",
335            ), "`cluster_scaling` must be in ('standard', 'robust', 'minmax')"
336
337        assert backend in (
338            "cpu",
339            "gpu",
340            "tpu",
341        ), "`backend` must be in ('cpu', 'gpu', 'tpu')"
342
343        assert solver in (
344            "ridge",
345            "lasso",
346            "enet",
347        ), "`solver` must be in ('ridge', 'lasso', 'enet')"
348
349        sys_platform = platform.system()
350
351        if (sys_platform == "Windows") and (backend in ("gpu", "tpu")):
352            warnings.warn(
353                "No GPU/TPU computing on Windows yet, backend set to 'cpu'"
354            )
355            backend = "cpu"
356
357        self.n_estimators = n_estimators
358        self.learning_rate = learning_rate
359        self.n_hidden_features = n_hidden_features
360        self.reg_lambda = reg_lambda
361        assert alpha >= 0 and alpha <= 1, "`alpha` must be in [0, 1]"
362        self.alpha = alpha
363        self.row_sample = row_sample
364        self.col_sample = col_sample
365        self.dropout = dropout
366        self.tolerance = tolerance
367        self.direct_link = direct_link
368        self.verbose = verbose
369        self.seed = seed
370        self.backend = backend
371        self.obj = None
372        self.solver = solver
373        self.activation = activation
374        self.n_clusters = n_clusters
375        self.clustering_method = clustering_method
376        self.cluster_scaling = cluster_scaling
377        self.scaler_, self.label_encoder_, self.clusterer_ = None, None, None
378        self.degree = degree
379        self.poly_ = None
380        self.weights_distr = weights_distr
381        if self.backend in ("gpu", "tpu"):
382            check_and_install("jax")
383            check_and_install("jaxlib")
384
385    def fit(self, X, y, **kwargs):
386        """Fit Booster (classifier) to training data (X, y)
387
388        Args:
389
390            X: {array-like}, shape = [n_samples, n_features]
391                Training vectors, where n_samples is the number
392                of samples and n_features is the number of features.
393
394            y: array-like, shape = [n_samples]
395                Target values.
396
397            **kwargs: additional parameters to be passed to self.cook_training_set.
398
399        Returns:
400
401            self: object.
402        """
403
404        if isinstance(X, pd.DataFrame):
405            X = X.values
406
407        if self.hist == True:
408            X, self.hist_bins_ = get_histo_features(X)
409
410        if isinstance(y, pd.Series):
411            y = y.values.ravel()
412        else:
413            y = y.ravel()
414
415        if self.degree is not None:
416            assert isinstance(self.degree, int), "`degree` must be an integer"
417            self.poly_ = PolynomialFeatures(
418                degree=self.degree, interaction_only=True, include_bias=False
419            )
420            X = self.poly_.fit_transform(X)
421
422        if self.n_clusters > 0:
423            clustered_X, self.scaler_, self.label_encoder_, self.clusterer_ = (
424                cluster(
425                    X,
426                    n_clusters=self.n_clusters,
427                    method=self.clustering_method,
428                    type_scaling=self.cluster_scaling,
429                    training=True,
430                    seed=self.seed,
431                )
432            )
433            X = np.column_stack((X, clustered_X))
434
435        self.obj = boosterc.fit_booster_classifier(
436            np.asarray(X, order="C"),
437            np.asarray(y, order="C"),
438            n_estimators=self.n_estimators,
439            learning_rate=self.learning_rate,
440            n_hidden_features=self.n_hidden_features,
441            reg_lambda=self.reg_lambda,
442            alpha=self.alpha,
443            row_sample=self.row_sample,
444            col_sample=self.col_sample,
445            dropout=self.dropout,
446            tolerance=self.tolerance,
447            direct_link=self.direct_link,
448            verbose=self.verbose,
449            seed=self.seed,
450            backend=self.backend,
451            solver=self.solver,
452            activation=self.activation,
453            obj=self.base_model,
454        )
455
456        self.classes_ = np.unique(y)  # for compatibility with sklearn
457        self.n_classes_ = len(self.classes_)  # for compatibility with sklearn
458        self.n_estimators = self.obj["n_estimators"]
459        return self
460
461    def predict(self, X, **kwargs):
462        """Predict test data X.
463
464        Args:
465
466            X: {array-like}, shape = [n_samples, n_features]
467                Training vectors, where n_samples is the number
468                of samples and n_features is the number of features.
469
470            **kwargs: additional parameters to be passed to `predict_proba`
471
472
473        Returns:
474
475            model predictions: {array-like}
476        """
477
478        return np.argmax(self.predict_proba(X, **kwargs), axis=1)
479
480    def predict_proba(self, X, **kwargs):
481        """Predict probabilities for test data X.
482
483        Args:
484
485            X: {array-like}, shape = [n_samples, n_features]
486                Training vectors, where n_samples is the number
487                of samples and n_features is the number of features.
488
489            **kwargs: additional parameters to be passed to
490                self.cook_test_set
491
492        Returns:
493
494            probability estimates for test data: {array-like}
495        """
496
497        if isinstance(X, pd.DataFrame):
498            X = X.values
499
500        if self.hist == True:
501            X = get_histo_features(X, bins=self.hist_bins_)
502
503        if self.degree is not None:
504            X = self.poly_.transform(X)
505
506        if self.n_clusters > 0:
507            X = np.column_stack(
508                (
509                    X,
510                    cluster(
511                        X,
512                        training=False,
513                        scaler=self.scaler_,
514                        label_encoder=self.label_encoder_,
515                        clusterer=self.clusterer_,
516                        seed=self.seed,
517                    ),
518                )
519            )
520        try:
521            return boosterc.predict_proba_booster_classifier(
522                self.obj, np.asarray(X, order="C")
523            )
524        except ValueError:
525            pass
526
527    def update(self, X, y, eta=0.9):
528        """Update model with new data.
529
530        Args:
531
532            X: {array-like}, shape = [n_samples=1, n_features]
533                Training vectors, where n_samples is the number
534                of samples and n_features is the number of features.
535
536            y: float = [n_samples=1]
537               Target value.
538
539            eta: float
540                Inverse power applied to number of observations
541                (defines a learning rate).
542
543        Returns:
544
545            self: object.
546        """
547
548        if isinstance(X, pd.DataFrame):
549            X = X.values
550
551        if self.degree is not None:
552            X = self.poly_.transform(X)
553
554        if self.n_clusters > 0:
555            X = np.column_stack(
556                (
557                    X,
558                    cluster(
559                        X,
560                        training=False,
561                        scaler=self.scaler_,
562                        label_encoder=self.label_encoder_,
563                        clusterer=self.clusterer_,
564                        seed=self.seed,
565                    ),
566                )
567            )
568
569        self.obj = boosterc.update_booster(
570            self.obj,
571            np.asarray(X, order="C"),
572            np.asarray(y, order="C").ravel(),
573            eta,
574        )
575
576        return self