diff --git a/mlsauce/adaopt/_adaopt.py b/mlsauce/adaopt/_adaopt.py index d115902..5919f9e 100644 --- a/mlsauce/adaopt/_adaopt.py +++ b/mlsauce/adaopt/_adaopt.py @@ -16,7 +16,7 @@ import pyximport pyximport.install() - import _adaoptc as adaoptc + import _adaoptc class AdaOpt(BaseEstimator, ClassifierMixin): @@ -203,21 +203,40 @@ def fit(self, X, y, **kwargs): n_classes = len(np.unique(y_)) assert n == len(y_), "must have X.shape[0] == len(y)" - - res = adaoptc.fit_adaopt( - X=np.asarray(X_).astype(np.float64), - y=np.asarray(y_).astype(np.int64), - n_iterations=self.n_iterations, - n_X=n, - p_X=p, - n_classes=n_classes, - learning_rate=self.learning_rate, - reg_lambda=self.reg_lambda, - reg_alpha=self.reg_alpha, - eta=self.eta, - gamma=self.gamma, - tolerance=self.tolerance, - ) + + try: + + res = adaoptc.fit_adaopt( + X=np.asarray(X_).astype(np.float64), + y=np.asarray(y_).astype(np.int64), + n_iterations=self.n_iterations, + n_X=n, + p_X=p, + n_classes=n_classes, + learning_rate=self.learning_rate, + reg_lambda=self.reg_lambda, + reg_alpha=self.reg_alpha, + eta=self.eta, + gamma=self.gamma, + tolerance=self.tolerance, + ) + + except ValueError: + + res = _adaoptc.fit_adaopt( + X=np.asarray(X_).astype(np.float64), + y=np.asarray(y_).astype(np.int64), + n_iterations=self.n_iterations, + n_X=n, + p_X=p, + n_classes=n_classes, + learning_rate=self.learning_rate, + reg_lambda=self.reg_lambda, + reg_alpha=self.reg_alpha, + eta=self.eta, + gamma=self.gamma, + tolerance=self.tolerance, + ) self.probs_training = res["probs"] self.training_accuracy = res["training_accuracy"] @@ -287,21 +306,38 @@ def predict_proba(self, X, **kwargs): n_test = X.shape[0] if self.n_jobs is None: - return adaoptc.predict_proba_adaopt( - X_test=np.asarray(X, order="C").astype(np.float64), - scaled_X_train=np.asarray( - self.scaled_X_train, order="C" - ).astype(np.float64), - n_test=n_test, - n_train=n_train, - probs_train=self.probs_training, - k=self.k, - n_clusters=self.n_clusters, - batch_size=self.batch_size, - type_dist=self.type_dist, - cache=self.cache, - seed=self.seed, - ) + try: + return adaoptc.predict_proba_adaopt( + X_test=np.asarray(X, order="C").astype(np.float64), + scaled_X_train=np.asarray( + self.scaled_X_train, order="C" + ).astype(np.float64), + n_test=n_test, + n_train=n_train, + probs_train=self.probs_training, + k=self.k, + n_clusters=self.n_clusters, + batch_size=self.batch_size, + type_dist=self.type_dist, + cache=self.cache, + seed=self.seed, + ) + except ValueError: + return _adaoptc.predict_proba_adaopt( + X_test=np.asarray(X, order="C").astype(np.float64), + scaled_X_train=np.asarray( + self.scaled_X_train, order="C" + ).astype(np.float64), + n_test=n_test, + n_train=n_train, + probs_train=self.probs_training, + k=self.k, + n_clusters=self.n_clusters, + batch_size=self.batch_size, + type_dist=self.type_dist, + cache=self.cache, + seed=self.seed, + ) # parallel: self.n_jobs is not None assert self.type_dist in ( @@ -312,99 +348,197 @@ def predict_proba(self, X, **kwargs): scaled_X_test = X / norm(X, ord=2, axis=1)[:, None] - if self.type_dist == "euclidean": - - @delayed - @wrap_non_picklable_objects - def multiproc_func(i): - dists_test_i = adaoptc.distance_to_mat_euclidean2( - np.asarray(scaled_X_test.astype(np.float64), order="C")[ - i, : - ], - np.asarray( - self.scaled_X_train.astype(np.float64), order="C" - ), - np.zeros(n_train), - n_train, - p_train, - ) - - kmin_test_i = adaoptc.find_kmin_x( - dists_test_i, n_x=n_train, k=self.k, cache=self.cache - ) - - weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) - - probs_test_i = adaoptc.calculate_probs( - kmin_test_i[1], self.probs_training - ) - - return adaoptc.average_probs( - probs=probs_test_i, weights=weights_test_i - ) - - if self.type_dist == "manhattan": - - @delayed - @wrap_non_picklable_objects - def multiproc_func(i): - dists_test_i = adaoptc.distance_to_mat_manhattan2( - np.asarray(scaled_X_test.astype(np.float64), order="C")[ - i, : - ], - np.asarray( - self.scaled_X_train.astype(np.float64), order="C" - ), - np.zeros(n_train), - n_train, - p_train, - ) - - kmin_test_i = adaoptc.find_kmin_x( - dists_test_i, n_x=n_train, k=self.k, cache=self.cache - ) - - weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) - - probs_test_i = adaoptc.calculate_probs( - kmin_test_i[1], self.probs_training - ) - - return adaoptc.average_probs( - probs=probs_test_i, weights=weights_test_i - ) - - if self.type_dist == "cosine": - - @delayed - @wrap_non_picklable_objects - def multiproc_func(i, *args): - dists_test_i = adaoptc.distance_to_mat_cosine2( - np.asarray(scaled_X_test.astype(np.float64), order="C")[ - i, : - ], - np.asarray( - self.scaled_X_train.astype(np.float64), order="C" - ), - np.zeros(n_train), - n_train, - p_train, - ) - - kmin_test_i = adaoptc.find_kmin_x( - dists_test_i, n_x=n_train, k=self.k, cache=self.cache - ) - - weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) - - probs_test_i = adaoptc.calculate_probs( - kmin_test_i[1], self.probs_training - ) - - return adaoptc.average_probs( - probs=probs_test_i, weights=weights_test_i - ) - + try: + + if self.type_dist == "euclidean": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i): + dists_test_i = adaoptc.distance_to_mat_euclidean2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + if self.type_dist == "manhattan": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i): + dists_test_i = adaoptc.distance_to_mat_manhattan2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + if self.type_dist == "cosine": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i, *args): + dists_test_i = adaoptc.distance_to_mat_cosine2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + except ValueError: + + if self.type_dist == "euclidean": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i): + dists_test_i = _adaoptc.distance_to_mat_euclidean2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = _adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = _adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = _adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return _adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + if self.type_dist == "manhattan": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i): + dists_test_i = _adaoptc.distance_to_mat_manhattan2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = _adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = _adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = _adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return _adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + if self.type_dist == "cosine": + + @delayed + @wrap_non_picklable_objects + def multiproc_func(i, *args): + dists_test_i = _adaoptc.distance_to_mat_cosine2( + np.asarray(scaled_X_test.astype(np.float64), order="C")[ + i, : + ], + np.asarray( + self.scaled_X_train.astype(np.float64), order="C" + ), + np.zeros(n_train), + n_train, + p_train, + ) + + kmin_test_i = _adaoptc.find_kmin_x( + dists_test_i, n_x=n_train, k=self.k, cache=self.cache + ) + + weights_test_i = _adaoptc.calculate_weights(kmin_test_i[0]) + + probs_test_i = _adaoptc.calculate_probs( + kmin_test_i[1], self.probs_training + ) + + return _adaoptc.average_probs( + probs=probs_test_i, weights=weights_test_i + ) + + if self.verbose == 1: res = Parallel(n_jobs=self.n_jobs, prefer="threads")( (multiproc_func)(m) for m in tqdm(range(n_test)) diff --git a/mlsauce/booster/_booster_classifier.py b/mlsauce/booster/_booster_classifier.py index 1e7151e..600b9b1 100644 --- a/mlsauce/booster/_booster_classifier.py +++ b/mlsauce/booster/_booster_classifier.py @@ -2,9 +2,8 @@ from . import _boosterc as boosterc except ImportError: import pyximport - pyximport.install() - import _boosterc as boosterc + import _boosterc import numpy as np import pandas as pd import platform @@ -193,24 +192,45 @@ def fit(self, X, y, **kwargs): ) X = np.column_stack((X, clustered_X)) - self.obj = boosterc.fit_booster_classifier( - np.asarray(X, order="C"), - np.asarray(y, order="C"), - n_estimators=self.n_estimators, - learning_rate=self.learning_rate, - n_hidden_features=self.n_hidden_features, - reg_lambda=self.reg_lambda, - row_sample=self.row_sample, - col_sample=self.col_sample, - dropout=self.dropout, - tolerance=self.tolerance, - direct_link=self.direct_link, - verbose=self.verbose, - seed=self.seed, - backend=self.backend, - solver=self.solver, - activation=self.activation, - ) + try: + self.obj = boosterc.fit_booster_classifier( + np.asarray(X, order="C"), + np.asarray(y, order="C"), + n_estimators=self.n_estimators, + learning_rate=self.learning_rate, + n_hidden_features=self.n_hidden_features, + reg_lambda=self.reg_lambda, + row_sample=self.row_sample, + col_sample=self.col_sample, + dropout=self.dropout, + tolerance=self.tolerance, + direct_link=self.direct_link, + verbose=self.verbose, + seed=self.seed, + backend=self.backend, + solver=self.solver, + activation=self.activation, + ) + except ValueError: + self.obj = _boosterc.fit_booster_classifier( + np.asarray(X, order="C"), + np.asarray(y, order="C"), + n_estimators=self.n_estimators, + learning_rate=self.learning_rate, + n_hidden_features=self.n_hidden_features, + reg_lambda=self.reg_lambda, + row_sample=self.row_sample, + col_sample=self.col_sample, + dropout=self.dropout, + tolerance=self.tolerance, + direct_link=self.direct_link, + verbose=self.verbose, + seed=self.seed, + backend=self.backend, + solver=self.solver, + activation=self.activation, + ) + self.n_classes_ = len(np.unique(y)) # for compatibility with sklearn self.n_estimators = self.obj["n_estimators"] return self @@ -271,6 +291,11 @@ def predict_proba(self, X, **kwargs): ), ) ) - return boosterc.predict_proba_booster_classifier( - self.obj, np.asarray(X, order="C") - ) + try: + return boosterc.predict_proba_booster_classifier( + self.obj, np.asarray(X, order="C") + ) + except ValueError: + return _boosterc.predict_proba_booster_classifier( + self.obj, np.asarray(X, order="C") + ) diff --git a/mlsauce/booster/_booster_regressor.py b/mlsauce/booster/_booster_regressor.py index 57e74c0..b0b8d65 100644 --- a/mlsauce/booster/_booster_regressor.py +++ b/mlsauce/booster/_booster_regressor.py @@ -4,7 +4,7 @@ import pyximport pyximport.install() - import _boosterc as boosterc + import _boosterc import numpy as np import pandas as pd import platform @@ -210,24 +210,44 @@ def fit(self, X, y, **kwargs): ) X = np.column_stack((X, clustered_X)) - self.obj = boosterc.fit_booster_regressor( - X=np.asarray(X, order="C"), - y=np.asarray(y, order="C"), - n_estimators=self.n_estimators, - learning_rate=self.learning_rate, - n_hidden_features=self.n_hidden_features, - reg_lambda=self.reg_lambda, - row_sample=self.row_sample, - col_sample=self.col_sample, - dropout=self.dropout, - tolerance=self.tolerance, - direct_link=self.direct_link, - verbose=self.verbose, - seed=self.seed, - backend=self.backend, - solver=self.solver, - activation=self.activation, - ) + try: + self.obj = boosterc.fit_booster_regressor( + X=np.asarray(X, order="C"), + y=np.asarray(y, order="C"), + n_estimators=self.n_estimators, + learning_rate=self.learning_rate, + n_hidden_features=self.n_hidden_features, + reg_lambda=self.reg_lambda, + row_sample=self.row_sample, + col_sample=self.col_sample, + dropout=self.dropout, + tolerance=self.tolerance, + direct_link=self.direct_link, + verbose=self.verbose, + seed=self.seed, + backend=self.backend, + solver=self.solver, + activation=self.activation, + ) + except ValueError: + self.obj = _boosterc.fit_booster_regressor( + X=np.asarray(X, order="C"), + y=np.asarray(y, order="C"), + n_estimators=self.n_estimators, + learning_rate=self.learning_rate, + n_hidden_features=self.n_hidden_features, + reg_lambda=self.reg_lambda, + row_sample=self.row_sample, + col_sample=self.col_sample, + dropout=self.dropout, + tolerance=self.tolerance, + direct_link=self.direct_link, + verbose=self.verbose, + seed=self.seed, + backend=self.backend, + solver=self.solver, + activation=self.activation, + ) self.n_estimators = self.obj["n_estimators"] @@ -300,6 +320,11 @@ def predict(self, X, level=95, method=None, **kwargs): preds = self.pi.predict(X, return_pi=True) return preds - return boosterc.predict_booster_regressor( - self.obj, np.asarray(X, order="C") - ) + try: + return boosterc.predict_booster_regressor( + self.obj, np.asarray(X, order="C") + ) + except ValueError: + return _boosterc.predict_booster_regressor( + self.obj, np.asarray(X, order="C") + ) diff --git a/mlsauce/lasso/_lasso.py b/mlsauce/lasso/_lasso.py index dd9c52a..76948e9 100644 --- a/mlsauce/lasso/_lasso.py +++ b/mlsauce/lasso/_lasso.py @@ -12,7 +12,7 @@ import pyximport pyximport.install() - import _lassoc as mo + import _lassoc from ..utils import get_beta if platform.system() in ("Linux", "Darwin"): @@ -79,20 +79,46 @@ def fit(self, X, y, **kwargs): self: object. """ + try: + + self.ym, centered_y = mo.center_response(y) + self.xm = X.mean(axis=0) + self.xsd = X.std(axis=0) + self.xsd[self.xsd == 0] = 1 + X_ = (X - self.xm[None, :]) / self.xsd[None, :] + XX = mo.crossprod(X_, backend=self.backend) + Xy = mo.crossprod(X_, centered_y, backend=self.backend) + XX2 = 2 * XX + Xy2 = 2 * Xy + + if self.backend == "cpu": + # beta0, _, _, _ = np.linalg.lstsq(X_, centered_y, rcond=None) + beta0 = get_beta(X_, centered_y) + if len(np.asarray(y).shape) == 1: + res = mo.get_beta_1D( + beta0=np.asarray(beta0), + XX2=np.asarray(XX2), + Xy2=np.asarray(Xy2), + reg_lambda=self.reg_lambda, + max_iter=self.max_iter, + tol=self.tol, + ) + self.beta = res[0] + return self + + res = mo.get_beta_2D( + beta0=np.asarray(beta0), + XX2=np.asarray(XX2), + Xy2=np.asarray(Xy2), + reg_lambda=self.reg_lambda, + max_iter=self.max_iter, + tol=self.tol, + ) + self.beta = res[0] + return self - self.ym, centered_y = mo.center_response(y) - self.xm = X.mean(axis=0) - self.xsd = X.std(axis=0) - self.xsd[self.xsd == 0] = 1 - X_ = (X - self.xm[None, :]) / self.xsd[None, :] - XX = mo.crossprod(X_, backend=self.backend) - Xy = mo.crossprod(X_, centered_y, backend=self.backend) - XX2 = 2 * XX - Xy2 = 2 * Xy - - if self.backend == "cpu": - # beta0, _, _, _ = np.linalg.lstsq(X_, centered_y, rcond=None) - beta0 = get_beta(X_, centered_y) + invXX = jinv(XX + self.reg_lambda * jnp.eye(X_.shape[1])) + beta0 = mo.safe_sparse_dot(invXX, Xy, backend=self.backend) if len(np.asarray(y).shape) == 1: res = mo.get_beta_1D( beta0=np.asarray(beta0), @@ -115,11 +141,60 @@ def fit(self, X, y, **kwargs): ) self.beta = res[0] return self + + except ValueError: + + self.ym, centered_y = _lassoc.center_response(y) + self.xm = X.mean(axis=0) + self.xsd = X.std(axis=0) + self.xsd[self.xsd == 0] = 1 + X_ = (X - self.xm[None, :]) / self.xsd[None, :] + XX = _lassoc.crossprod(X_, backend=self.backend) + Xy = _lassoc.crossprod(X_, centered_y, backend=self.backend) + XX2 = 2 * XX + Xy2 = 2 * Xy + + if self.backend == "cpu": + # beta0, _, _, _ = np.linalg.lstsq(X_, centered_y, rcond=None) + beta0 = get_beta(X_, centered_y) + if len(np.asarray(y).shape) == 1: + res = _lassoc.get_beta_1D( + beta0=np.asarray(beta0), + XX2=np.asarray(XX2), + Xy2=np.asarray(Xy2), + reg_lambda=self.reg_lambda, + max_iter=self.max_iter, + tol=self.tol, + ) + self.beta = res[0] + return self + + res = _lassoc.get_beta_2D( + beta0=np.asarray(beta0), + XX2=np.asarray(XX2), + Xy2=np.asarray(Xy2), + reg_lambda=self.reg_lambda, + max_iter=self.max_iter, + tol=self.tol, + ) + self.beta = res[0] + return self - invXX = jinv(XX + self.reg_lambda * jnp.eye(X_.shape[1])) - beta0 = mo.safe_sparse_dot(invXX, Xy, backend=self.backend) - if len(np.asarray(y).shape) == 1: - res = mo.get_beta_1D( + invXX = jinv(XX + self.reg_lambda * jnp.eye(X_.shape[1])) + beta0 = _lassoc.safe_sparse_dot(invXX, Xy, backend=self.backend) + if len(np.asarray(y).shape) == 1: + res = _lassoc.get_beta_1D( + beta0=np.asarray(beta0), + XX2=np.asarray(XX2), + Xy2=np.asarray(Xy2), + reg_lambda=self.reg_lambda, + max_iter=self.max_iter, + tol=self.tol, + ) + self.beta = res[0] + return self + + res = _lassoc.get_beta_2D( beta0=np.asarray(beta0), XX2=np.asarray(XX2), Xy2=np.asarray(Xy2), @@ -130,16 +205,7 @@ def fit(self, X, y, **kwargs): self.beta = res[0] return self - res = mo.get_beta_2D( - beta0=np.asarray(beta0), - XX2=np.asarray(XX2), - Xy2=np.asarray(Xy2), - reg_lambda=self.reg_lambda, - max_iter=self.max_iter, - tol=self.tol, - ) - self.beta = res[0] - return self + def predict(self, X, **kwargs): """Predict test data X. diff --git a/mlsauce/ridge/_ridge.py b/mlsauce/ridge/_ridge.py index 182340c..aa944ed 100644 --- a/mlsauce/ridge/_ridge.py +++ b/mlsauce/ridge/_ridge.py @@ -11,7 +11,7 @@ import pyximport pyximport.install() - import _ridgec as mo + import _ridgec from ..utils import get_beta if platform.system() in ("Linux", "Darwin"): @@ -70,7 +70,10 @@ def fit(self, X, y, **kwargs): self: object. """ - self.ym, centered_y = mo.center_response(y) + try: + self.ym, centered_y = mo.center_response(y) + except ValueError: + self.ym, centered_y = _ridgec.center_response(y) self.xm = X.mean(axis=0) self.xsd = X.std(axis=0) self.xsd[self.xsd == 0] = 1 # avoid division by zero @@ -96,21 +99,38 @@ def fit(self, X, y, **kwargs): # self.beta, _, _, _ = np.linalg.lstsq(X_, y_, rcond=None) self.beta = get_beta(X_, y_) except Exception: - x = inv( - mo.crossprod(X_) + self.reg_lambda * np.eye(X_.shape[1]) - ) - hat_matrix = mo.tcrossprod(x, X_) - self.beta = mo.safe_sparse_dot(hat_matrix, centered_y) + try: + x = inv( + mo.crossprod(X_) + self.reg_lambda * np.eye(X_.shape[1]) + ) + hat_matrix = mo.tcrossprod(x, X_) + self.beta = mo.safe_sparse_dot(hat_matrix, centered_y) + except ValueError: + x = inv( + _ridgec.crossprod(X_) + self.reg_lambda * np.eye(X_.shape[1]) + ) + hat_matrix = _ridgec.tcrossprod(x, X_) + self.beta = _ridgec.safe_sparse_dot(hat_matrix, centered_y) return self - x = jinv( - mo.crossprod(X_, backend=self.backend) - + self.reg_lambda * jnp.eye(X_.shape[1]) - ) - hat_matrix = mo.tcrossprod(x, X_, backend=self.backend) - self.beta = mo.safe_sparse_dot( - hat_matrix, centered_y, backend=self.backend - ) + try: + x = jinv( + mo.crossprod(X_, backend=self.backend) + + self.reg_lambda * jnp.eye(X_.shape[1]) + ) + hat_matrix = mo.tcrossprod(x, X_, backend=self.backend) + self.beta = mo.safe_sparse_dot( + hat_matrix, centered_y, backend=self.backend + ) + except ValueError: + x = jinv( + _ridgec.crossprod(X_, backend=self.backend) + + self.reg_lambda * jnp.eye(X_.shape[1]) + ) + hat_matrix = _ridgec.tcrossprod(x, X_, backend=self.backend) + self.beta = _ridgec.safe_sparse_dot( + hat_matrix, centered_y, backend=self.backend + ) return self def predict(self, X, **kwargs): @@ -131,16 +151,30 @@ def predict(self, X, **kwargs): """ X_ = (X - self.xm[None, :]) / self.xsd[None, :] - if self.backend == "cpu": - if isinstance(self.ym, float): - return self.ym + mo.safe_sparse_dot(X_, self.beta) - return self.ym[None, :] + mo.safe_sparse_dot(X_, self.beta) + try: + if self.backend == "cpu": + if isinstance(self.ym, float): + return self.ym + mo.safe_sparse_dot(X_, self.beta) + return self.ym[None, :] + mo.safe_sparse_dot(X_, self.beta) - # if self.backend in ("gpu", "tpu"): - if isinstance(self.ym, float): - return self.ym + mo.safe_sparse_dot( + # if self.backend in ("gpu", "tpu"): + if isinstance(self.ym, float): + return self.ym + mo.safe_sparse_dot( + X_, self.beta, backend=self.backend + ) + return self.ym[None, :] + mo.safe_sparse_dot( X_, self.beta, backend=self.backend ) - return self.ym[None, :] + mo.safe_sparse_dot( - X_, self.beta, backend=self.backend - ) + except ValueError: + if self.backend == "cpu": + if isinstance(self.ym, float): + return self.ym + _ridgec.safe_sparse_dot(X_, self.beta) + return self.ym[None, :] + _ridgec.safe_sparse_dot(X_, self.beta) + + # if self.backend in ("gpu", "tpu"): + if isinstance(self.ym, float): + return self.ym + _ridgec.safe_sparse_dot(X_, self.beta, backend=self.backend) + return self.ym[None, :] + _ridgec.safe_sparse_dot(X_, self.beta, backend=self.backend) + + + diff --git a/mlsauce/stump/_stump_classifier.py b/mlsauce/stump/_stump_classifier.py index eed622a..c314e27 100644 --- a/mlsauce/stump/_stump_classifier.py +++ b/mlsauce/stump/_stump_classifier.py @@ -8,7 +8,7 @@ import pyximport pyximport.install() - import _stumpc as stumpc + import _stumpc class StumpClassifier(BaseEstimator, ClassifierMixin): @@ -45,20 +45,35 @@ def fit(self, X, y, sample_weight=None, **kwargs): """ if sample_weight is None: + try: + self.obj = stumpc.fit_stump_classifier( + X=np.asarray(X, order="C"), + y=np.asarray(y, order="C"), + bins=self.bins, + ) + except ValueError: + self.obj = _stumpc.fit_stump_classifier( + X=np.asarray(X, order="C"), + y=np.asarray(y, order="C"), + bins=self.bins, + ) + + return self + + try: self.obj = stumpc.fit_stump_classifier( X=np.asarray(X, order="C"), y=np.asarray(y, order="C"), + sample_weight=np.ravel(sample_weight, order="C"), + bins=self.bins, + ) + except ValueError: + self.obj = _stumpc.fit_stump_classifier( + X=np.asarray(X, order="C"), + y=np.asarray(y, order="C"), + sample_weight=np.ravel(sample_weight, order="C"), bins=self.bins, ) - - return self - - self.obj = stumpc.fit_stump_classifier( - X=np.asarray(X, order="C"), - y=np.asarray(y, order="C"), - sample_weight=np.ravel(sample_weight, order="C"), - bins=self.bins, - ) self.n_classes_ = len(np.unique(y)) # for compatibility with sklearn return self @@ -97,7 +112,11 @@ def predict_proba(self, X, **kwargs): probability estimates for test data: {array-like} """ - - return stumpc.predict_proba_stump_classifier( - self.obj, np.asarray(X, order="C") - ) + try: + return stumpc.predict_proba_stump_classifier( + self.obj, np.asarray(X, order="C") + ) + except ValueError: + return _stumpc.predict_proba_stump_classifier( + self.obj, np.asarray(X, order="C") + ) diff --git a/setup.py b/setup.py index c470544..5064e13 100644 --- a/setup.py +++ b/setup.py @@ -115,6 +115,7 @@ def run(self): import wheelhouse_uploader.cmd cmdclass.update(vars(wheelhouse_uploader.cmd)) + ext_modules =[ Extension(name="mlsauce.adaopt._adaoptc", library_dirs=["mlsauce/adaopt/"], @@ -143,39 +144,6 @@ def run(self): include_dirs=[numpy.get_include()]), ] -# Get the absolute path to the directory containing the setup script -script_dir = os.path.basename(__file__) -# Get absolute paths to Cython source files -adaopt_cython_file = str(script_dir + 'mlsauce/adaopt/_adaoptc.pyx') -booster_cython_file = str(script_dir + 'mlsauce/booster/_boosterc.pyx') -lasso_cython_file = str(script_dir + 'mlsauce/lasso/_lassoc.pyx') -ridge_cython_file = str(script_dir + 'mlsauce/ridge/_ridgec.pyx') -stump_cython_file = str(script_dir + 'mlsauce/stump/_stumpc.pyx') -# Update Extension definitions with absolute paths -ext_modules2 = [ - Extension(name="mlsauce.adaopt._adaoptc", - sources=[adaopt_cython_file], - include_dirs=[numpy.get_include()], - packages=["adaopt"]), - Extension(name="mlsauce.booster._boosterc", - sources=[booster_cython_file], - include_dirs=[numpy.get_include()], - packages=["booster"]), - Extension(name="mlsauce.lasso._lassoc", - sources=[lasso_cython_file], - include_dirs=[numpy.get_include()], - packages=["lasso"]), - Extension(name="mlsauce.ridge._ridgec", - sources=[ridge_cython_file], - include_dirs=[numpy.get_include()], - packages=["ridge"]), - Extension(name="mlsauce.stump._stumpc", - sources=[booster_cython_file], - include_dirs=[numpy.get_include()], - packages=["stump"]), -] - - def setup_package(): install_all_requires = [ @@ -199,10 +167,7 @@ def setup_package(): try: cythonize_ext_modules = cythonize(ext_modules) except ValueError: - try: - cythonize_ext_modules = cythonize(ext_modules2) - except ValueError: - cythonize_ext_modules = [] + cythonize_ext_modules = [] metadata = dict(name=DISTNAME, maintainer=MAINTAINER,