update: update neighbors.py to use pybind11 instead of daal4py

onedal/neighbors/neighbors.py

@@ -19,14 +19,6 @@
 
 import numpy as np
 
-from daal4py import (
-    bf_knn_classification_model,
-    bf_knn_classification_prediction,
-    bf_knn_classification_training,
-    kdtree_knn_classification_model,
-    kdtree_knn_classification_prediction,
-    kdtree_knn_classification_training,
-)
 from onedal._device_offload import supports_queue
 from onedal.common._backend import bind_default_backend
 from onedal.utils import _sycl_queue_manager as QM
@@ -166,25 +158,6 @@ def _get_onedal_params(self, X, y=None, n_neighbors=None):
             "result_option": "indices|distances" if y is None else "responses",
         }
 
-    def _get_daal_params(self, data, n_neighbors=None):
-        class_count = 0 if self.classes_ is None else len(self.classes_)
-        weights = getattr(self, "weights", "uniform")
-        params = {
-            "fptype": "float" if data.dtype == np.float32 else "double",
-            "method": "defaultDense",
-            "k": self.n_neighbors if n_neighbors is None else n_neighbors,
-            "voteWeights": "voteUniform" if weights == "uniform" else "voteDistance",
-            "resultsToCompute": "computeIndicesOfNeighbors|computeDistances",
-            "resultsToEvaluate": (
-                "none"
-                if getattr(self, "_y", None) is None or _is_regressor(self)
-                else "computeClassLabels"
-            ),
-        }
-        if class_count != 0:
-            params["nClasses"] = class_count
-        return params
-
 
 class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
     def __init__(
@@ -348,19 +321,10 @@ def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
             self._fit_method, self.n_samples_fit_, n_features
         )
 
-        if type(self._onedal_model) in (
-            kdtree_knn_classification_model,
-            bf_knn_classification_model,
-        ):
-            params = super()._get_daal_params(X, n_neighbors=n_neighbors)
-            prediction_results = self._onedal_predict(self._onedal_model, X, params)
-            distances = prediction_results.distances
-            indices = prediction_results.indices
-        else:
-            params = super()._get_onedal_params(X, n_neighbors=n_neighbors)
-            prediction_results = self._onedal_predict(self._onedal_model, X, params)
-            distances = from_table(prediction_results.distances)
-            indices = from_table(prediction_results.indices)
+        params = super()._get_onedal_params(X, n_neighbors=n_neighbors)
+        prediction_results = self._onedal_predict(self._onedal_model, X, params)
+        distances = from_table(prediction_results.distances)
+        indices = from_table(prediction_results.indices)
 
         if method == "kd_tree":
             for i in range(distances.shape[0]):
@@ -443,43 +407,21 @@ def train(self, *args, **kwargs): ...
     @bind_default_backend("neighbors.classification")
     def infer(self, *args, **kwargs): ...
 
-    def _get_daal_params(self, data):
-        params = super()._get_daal_params(data)
-        params["resultsToEvaluate"] = "computeClassLabels"
-        params["resultsToCompute"] = ""
-        return params
-
     def _onedal_fit(self, X, y):
         # global queue is set as per user configuration (`target_offload`) or from data prior to calling this internal function
         queue = QM.get_global_queue()
-        gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            params = self._get_daal_params(X)
-            if self._fit_method == "brute":
-                train_alg = bf_knn_classification_training
-
-            else:
-                train_alg = kdtree_knn_classification_training
-
-            return train_alg(**params).compute(X, y).model
-        else:
-            params = self._get_onedal_params(X, y)
-            X_table, y_table = to_table(X, y, queue=queue)
-            return self.train(params, X_table, y_table).model
+        params = self._get_onedal_params(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        return self.train(params, X_table, y_table).model
 
     def _onedal_predict(self, model, X, params):
-        if type(self._onedal_model) is kdtree_knn_classification_model:
-            return kdtree_knn_classification_prediction(**params).compute(X, model)
-        elif type(self._onedal_model) is bf_knn_classification_model:
-            return bf_knn_classification_prediction(**params).compute(X, model)
-        else:
-            X = to_table(X, queue=QM.get_global_queue())
-            if "responses" not in params["result_option"]:
-                params["result_option"] += "|responses"
-            params["fptype"] = X.dtype
-            result = self.infer(params, model, X)
+        X = to_table(X, queue=QM.get_global_queue())
+        if "responses" not in params["result_option"]:
+            params["result_option"] += "|responses"
+        params["fptype"] = X.dtype
+        result = self.infer(params, model, X)
 
-            return result
+        return result
 
     @supports_queue
     def fit(self, X, y, queue=None):
@@ -511,17 +453,9 @@ def predict(self, X, queue=None):
 
         self._validate_n_classes()
 
-        if (
-            type(onedal_model) is kdtree_knn_classification_model
-            or type(onedal_model) is bf_knn_classification_model
-        ):
-            params = self._get_daal_params(X)
-            prediction_result = self._onedal_predict(onedal_model, X, params)
-            responses = prediction_result.prediction
-        else:
-            params = self._get_onedal_params(X)
-            prediction_result = self._onedal_predict(onedal_model, X, params)
-            responses = from_table(prediction_result.responses)
+        params = self._get_onedal_params(X)
+        prediction_result = self._onedal_predict(onedal_model, X, params)
+        responses = from_table(prediction_result.responses)
 
         result = self.classes_.take(np.asarray(responses.ravel(), dtype=np.intp))
         return result
@@ -603,25 +537,10 @@ def train(self, *args, **kwargs): ...
     @bind_default_backend("neighbors.regression")
     def infer(self, *args, **kwargs): ...
 
-    def _get_daal_params(self, data):
-        params = super()._get_daal_params(data)
-        params["resultsToCompute"] = "computeIndicesOfNeighbors|computeDistances"
-        params["resultsToEvaluate"] = "none"
-        return params
-
     def _onedal_fit(self, X, y):
         # global queue is set as per user configuration (`target_offload`) or from data prior to calling this internal function
         queue = QM.get_global_queue()
         gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            params = self._get_daal_params(X)
-            if self._fit_method == "brute":
-                train_alg = bf_knn_classification_training
-            else:
-                train_alg = kdtree_knn_classification_training
-
-            return train_alg(**params).compute(X, y).model
-
         X_table, y_table = to_table(X, y, queue=queue)
         params = self._get_onedal_params(X_table, y)
 
@@ -633,11 +552,6 @@ def _onedal_fit(self, X, y):
     def _onedal_predict(self, model, X, params):
         assert self._onedal_model is not None, "Model is not trained"
 
-        if type(model) is kdtree_knn_classification_model:
-            return kdtree_knn_classification_prediction(**params).compute(X, model)
-        elif type(model) is bf_knn_classification_model:
-            return bf_knn_classification_prediction(**params).compute(X, model)
-
         # global queue is set as per user configuration (`target_offload`) or from data prior to calling this internal function
         queue = QM.get_global_queue()
         gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
@@ -753,39 +667,14 @@ def train(self, *args, **kwargs): ...
     @bind_default_backend("neighbors.search")
     def infer(self, *arg, **kwargs): ...
 
-    def _get_daal_params(self, data):
-        params = super()._get_daal_params(data)
-        params["resultsToCompute"] = "computeIndicesOfNeighbors|computeDistances"
-        params["resultsToEvaluate"] = (
-            "none" if getattr(self, "_y", None) is None else "computeClassLabels"
-        )
-        return params
-
     def _onedal_fit(self, X, y):
         # global queue is set as per user configuration (`target_offload`) or from data prior to calling this internal function
         queue = QM.get_global_queue()
-        gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            params = self._get_daal_params(X)
-            if self._fit_method == "brute":
-                train_alg = bf_knn_classification_training
-
-            else:
-                train_alg = kdtree_knn_classification_training
-
-            return train_alg(**params).compute(X, y).model
-
-        else:
-            params = self._get_onedal_params(X, y)
-            X, y = to_table(X, y, queue=queue)
-            return self.train(params, X).model
+        params = self._get_onedal_params(X, y)
+        X, y = to_table(X, y, queue=queue)
+        return self.train(params, X).model
 
     def _onedal_predict(self, model, X, params):
-        if type(self._onedal_model) is kdtree_knn_classification_model:
-            return kdtree_knn_classification_prediction(**params).compute(X, model)
-        elif type(self._onedal_model) is bf_knn_classification_model:
-            return bf_knn_classification_prediction(**params).compute(X, model)
-
         X = to_table(X, queue=QM.get_global_queue())
 
         params["fptype"] = X.dtype

sklearnex/tests/test_common.py

@@ -103,6 +103,41 @@
     "LogisticRegression(solver='newton-cg')-predict-n_jobs_check": "uses daal4py for cpu in sklearnex",
     "LogisticRegression(solver='newton-cg')-predict_log_proba-n_jobs_check": "uses daal4py for cpu in sklearnex",
     "LogisticRegression(solver='newton-cg')-predict_proba-n_jobs_check": "uses daal4py for cpu in sklearnex",
+    # KNeighborsClassifier validate_data issues - will be fixed later
+    "KNeighborsClassifier-fit-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier-predict_proba-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier-score-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier-predict-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor-fit-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor-score-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor-predict-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors-fit-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor-fit-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor(novelty=True)-fit-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor(novelty=True)-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "LocalOutlierFactor(novelty=True)-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-fit-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-predict_proba-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-score-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsClassifier(algorithm='brute')-predict-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor(algorithm='brute')-fit-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor(algorithm='brute')-score-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor(algorithm='brute')-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor(algorithm='brute')-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
+    "KNeighborsRegressor(algorithm='brute')-predict-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors(algorithm='brute')-fit-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors(algorithm='brute')-kneighbors-call_validate_data": "validate_data implementation needs fixing",
+    "NearestNeighbors(algorithm='brute')-kneighbors_graph-call_validate_data": "validate_data implementation needs fixing",
 }