scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/neighbors/neighbors.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from abc import ABCMeta
+from abc import ABCMeta, abstractmethod
 from numbers import Integral
 
 import numpy as np
@@ -27,12 +27,16 @@ from daal4py import (
     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
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
 from ..common._estimator_checks import _check_is_fitted, _is_classifier, _is_regressor
 from ..common._mixin import ClassifierMixin, RegressorMixin
 from ..datatypes import from_table, to_table
-from ..utils import (
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import (
     _check_array,
     _check_classification_targets,
     _check_n_features,
@@ -42,7 +46,18 @@ from ..utils import (
 )
 
 
-class NeighborsCommonBase(BaseEstimator, metaclass=ABCMeta):
+class NeighborsCommonBase(metaclass=ABCMeta):
+    def __init__(self):
+        self.requires_y = False
+        self.n_neighbors = None
+        self.metric = None
+        self.classes_ = None
+        self.effective_metric_ = None
+        self._fit_method = None
+        self.radius = None
+        self.effective_metric_params_ = None
+        self._onedal_model = None
+
     def _parse_auto_method(self, method, n_samples, n_features):
         result_method = method
 
@@ -60,8 +75,17 @@ class NeighborsCommonBase(BaseEstimator, metaclass=ABCMeta):
 
         return result_method
 
+    @abstractmethod
+    def train(self, *args, **kwargs): ...
+
+    @abstractmethod
+    def infer(self, *args, **kwargs): ...
+
+    @abstractmethod
+    def _onedal_fit(self, X, y): ...
+
     def _validate_data(
-        self, X, y=None, reset=True, validate_separately=False, **check_params
+        self, X, y=None, reset=True, validate_separately=None, **check_params
     ):
         if y is None:
             if self.requires_y:
@@ -188,13 +212,13 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
             return arr
 
     def _validate_n_classes(self):
-        if len(self.classes_) < 2:
+        length = 0 if self.classes_ is None else len(self.classes_)
+        if length < 2:
             raise ValueError(
-                "The number of classes has to be greater than one; got %d"
-                " class" % len(self.classes_)
+                f"The number of classes has to be greater than one; got {length}"
             )
 
-    def _fit(self, X, y, queue):
+    def _fit(self, X, y):
         self._onedal_model = None
         self._tree = None
         self._shape = None
@@ -204,11 +228,14 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
             self, "effective_metric_params_", self.metric_params
         )
 
+        _, xp, _ = _get_sycl_namespace(X)
+        use_raw_input = _get_config().get("use_raw_input", False) is True
         if y is not None or self.requires_y:
             shape = getattr(y, "shape", None)
-            X, y = super()._validate_data(
-                X, y, dtype=[np.float64, np.float32], accept_sparse="csr"
-            )
+            if not use_raw_input:
+                X, y = super()._validate_data(
+                    X, y, dtype=[np.float64, np.float32], accept_sparse="csr"
+                )
             self._shape = shape if shape is not None else y.shape
 
             if _is_classifier(self):
@@ -232,7 +259,7 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
                 self._validate_n_classes()
             else:
                 self._y = y
-        else:
+        elif not use_raw_input:
             X, _ = super()._validate_data(X, dtype=[np.float64, np.float32])
 
         self.n_samples_fit_ = X.shape[0]
@@ -253,21 +280,22 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
         )
 
         _fit_y = None
+        queue = QM.get_global_queue()
         gpu_device = queue is not None and queue.sycl_device.is_gpu
 
         if _is_classifier(self) or (_is_regressor(self) and gpu_device):
             _fit_y = self._validate_targets(self._y, X.dtype).reshape((-1, 1))
-        result = self._onedal_fit(X, _fit_y, queue)
+        result = self._onedal_fit(X, _fit_y)
 
         if y is not None and _is_regressor(self):
-            self._y = y if self._shape is None else y.reshape(self._shape)
+            self._y = y if self._shape is None else xp.reshape(y, self._shape)
 
         self._onedal_model = result
         result = self
 
         return result
 
-    def _kneighbors(self, X=None, n_neighbors=None, return_distance=True, queue=None):
+    def _kneighbors(self, X=None, n_neighbors=None, return_distance=True):
         n_features = getattr(self, "n_features_in_", None)
         shape = getattr(X, "shape", None)
         if n_features and shape and len(shape) > 1 and shape[1] != n_features:
@@ -316,25 +344,21 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
             )
 
         chunked_results = None
-        method = super()._parse_auto_method(
+        method = self._parse_auto_method(
             self._fit_method, self.n_samples_fit_, n_features
         )
 
-        if (
-            type(self._onedal_model) is kdtree_knn_classification_model
-            or type(self._onedal_model) is bf_knn_classification_model
+        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, queue=queue
-            )
+            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, queue=queue
-            )
+            prediction_results = self._onedal_predict(self._onedal_model, X, params)
             distances = from_table(prediction_results.distances)
             indices = from_table(prediction_results.indices)
 
@@ -408,14 +432,27 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
         )
         self.weights = weights
 
+    # direct access to the backend model constructor
+    @bind_default_backend("neighbors.classification")
+    def model(self): ...
+
+    # direct access to the backend model constructor
+    @bind_default_backend("neighbors.classification")
+    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, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
+    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":
@@ -425,44 +462,34 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
                 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
 
-        policy = self._get_policy(queue, X, y)
-        X_table, y_table = to_table(X, y, queue=queue)
-        params = self._get_onedal_params(X_table, y)
-        train_alg = self._get_backend(
-            "neighbors", "classification", "train", policy, params, X_table, y_table
-        )
-
-        return train_alg.model
-
-    def _onedal_predict(self, model, X, params, queue):
+    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)
-
-        policy = self._get_policy(queue, X)
-        X = to_table(X, queue=queue)
-        if hasattr(self, "_onedal_model"):
-            model = self._onedal_model
         else:
-            model = self._create_model(
-                self._get_backend("neighbors", "classification", None)
-            )
-        if "responses" not in params["result_option"]:
-            params["result_option"] += "|responses"
-        params["fptype"] = X.dtype
-        result = self._get_backend(
-            "neighbors", "classification", "infer", policy, 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):
-        return super()._fit(X, y, queue=queue)
+        return self._fit(X, y)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
         onedal_model = getattr(self, "_onedal_model", None)
         n_features = getattr(self, "n_features_in_", None)
         n_samples_fit_ = getattr(self, "n_samples_fit_", None)
@@ -478,7 +505,7 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
 
         _check_is_fitted(self)
 
-        self._fit_method = super()._parse_auto_method(
+        self._fit_method = self._parse_auto_method(
             self.algorithm, n_samples_fit_, n_features
         )
 
@@ -489,16 +516,17 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
             or type(onedal_model) is bf_knn_classification_model
         ):
             params = self._get_daal_params(X)
-            prediction_result = self._onedal_predict(onedal_model, X, params, queue=queue)
+            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, queue=queue)
+            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
 
+    @supports_queue
     def predict_proba(self, X, queue=None):
         neigh_dist, neigh_ind = self.kneighbors(X, queue=queue)
 
@@ -536,8 +564,9 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
 
         return probabilities
 
+    @supports_queue
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True, queue=None):
-        return super()._kneighbors(X, n_neighbors, return_distance, queue=queue)
+        return self._kneighbors(X, n_neighbors, return_distance)
 
 
 class KNeighborsRegressor(NeighborsBase, RegressorMixin):
@@ -562,68 +591,79 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
         )
         self.weights = weights
 
+    @bind_default_backend("neighbors.search", lookup_name="train")
+    def train_search(self, *args, **kwargs): ...
+
+    @bind_default_backend("neighbors.search", lookup_name="infer")
+    def infer_search(self, *args, **kwargs): ...
+
+    @bind_default_backend("neighbors.regression")
+    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, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
+    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
 
-        policy = self._get_policy(queue, X, y)
         X_table, y_table = to_table(X, y, queue=queue)
         params = self._get_onedal_params(X_table, y)
-        train_alg_regr = self._get_backend("neighbors", "regression", None)
-        train_alg_srch = self._get_backend("neighbors", "search", None)
 
         if gpu_device:
-            return train_alg_regr.train(policy, params, X_table, y_table).model
-        return train_alg_srch.train(policy, params, X_table).model
+            return self.train(params, X_table, y_table).model
+        else:
+            return self.train_search(params, X_table).model
+
+    def _onedal_predict(self, model, X, params):
+        assert self._onedal_model is not None, "Model is not trained"
 
-    def _onedal_predict(self, model, X, params, queue):
         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)
 
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        policy = self._get_policy(queue, X)
+        # 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)
         X = to_table(X, queue=queue)
-        backend = (
-            self._get_backend("neighbors", "regression", None)
-            if gpu_device
-            else self._get_backend("neighbors", "search", None)
-        )
 
-        if hasattr(self, "_onedal_model"):
-            model = self._onedal_model
-        else:
-            model = self._create_model(backend)
         if "responses" not in params["result_option"] and gpu_device:
             params["result_option"] += "|responses"
         params["fptype"] = X.dtype
-        result = backend.infer(policy, params, model, X)
 
-        return result
+        if gpu_device:
+            return self.infer(params, self._onedal_model, X)
+        else:
+            return self.infer_search(params, self._onedal_model, X)
 
+    @supports_queue
     def fit(self, X, y, queue=None):
-        return super()._fit(X, y, queue=queue)
+        return self._fit(X, y)
 
+    @supports_queue
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True, queue=None):
-        return super()._kneighbors(X, n_neighbors, return_distance, queue=queue)
+        return self._kneighbors(X, n_neighbors, return_distance)
 
-    def _predict_gpu(self, X, queue=None):
-        X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+    def _predict_gpu(self, X):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
         onedal_model = getattr(self, "_onedal_model", None)
         n_features = getattr(self, "n_features_in_", None)
         n_samples_fit_ = getattr(self, "n_samples_fit_", None)
@@ -639,20 +679,20 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
 
         _check_is_fitted(self)
 
-        self._fit_method = super()._parse_auto_method(
+        self._fit_method = self._parse_auto_method(
             self.algorithm, n_samples_fit_, n_features
         )
 
         params = self._get_onedal_params(X)
 
-        prediction_result = self._onedal_predict(onedal_model, X, params, queue=queue)
+        prediction_result = self._onedal_predict(onedal_model, X, params)
         responses = from_table(prediction_result.responses)
         result = responses.ravel()
 
         return result
 
-    def _predict_skl(self, X, queue=None):
-        neigh_dist, neigh_ind = self.kneighbors(X, queue=queue)
+    def _predict_skl(self, X):
+        neigh_dist, neigh_ind = self.kneighbors(X)
 
         weights = self._get_weights(neigh_dist, self.weights)
 
@@ -675,14 +715,14 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
 
         return y_pred
 
+    @supports_queue
     def predict(self, X, queue=None):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
+        gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
         is_uniform_weights = getattr(self, "weights", "uniform") == "uniform"
-        return (
-            self._predict_gpu(X, queue=queue)
-            if gpu_device and is_uniform_weights
-            else self._predict_skl(X, queue=queue)
-        )
+        if gpu_device and is_uniform_weights:
+            return self._predict_gpu(X)
+        else:
+            return self._predict_skl(X)
 
 
 class NearestNeighbors(NeighborsBase):
@@ -707,6 +747,12 @@ class NearestNeighbors(NeighborsBase):
         )
         self.weights = weights
 
+    @bind_default_backend("neighbors.search")
+    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"
@@ -715,8 +761,10 @@ class NearestNeighbors(NeighborsBase):
         )
         return params
 
-    def _onedal_fit(self, X, y, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
+    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":
@@ -727,37 +775,26 @@ class NearestNeighbors(NeighborsBase):
 
             return train_alg(**params).compute(X, y).model
 
-        policy = self._get_policy(queue, X, y)
-        X_table = to_table(X, queue=queue)
-        params = self._get_onedal_params(X_table, y)
-        train_alg = self._get_backend(
-            "neighbors", "search", "train", policy, params, X_table
-        )
-
-        return train_alg.model
+        else:
+            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, queue):
+    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)
 
-        policy = self._get_policy(queue, X)
-        X = to_table(X, queue=queue)
-        if hasattr(self, "_onedal_model"):
-            model = self._onedal_model
-        else:
-            model = self._create_model(self._get_backend("neighbors", "search", None))
+        X = to_table(X, queue=QM.get_global_queue())
 
         params["fptype"] = X.dtype
-        result = self._get_backend(
-            "neighbors", "search", "infer", policy, params, model, X
-        )
-
-        return result
+        return self.infer(params, model, X)
 
+    @supports_queue
     def fit(self, X, y, queue=None):
-        return super()._fit(X, y, queue=queue)
+        return self._fit(X, y)
 
+    @supports_queue
     def kneighbors(self, X=None, n_neighbors=None, return_distance=True, queue=None):
-        return super()._kneighbors(X, n_neighbors, return_distance, queue=queue)
+        return self._kneighbors(X, n_neighbors, return_distance)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/primitives/get_tree.py

@@ -14,12 +14,14 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal import _backend
+from onedal import _default_backend, _dpc_backend
+
+backend = _dpc_backend or _default_backend
 
 
 def get_tree_state_cls(model, iTree, n_classes):
-    return _backend.get_tree.classification.get_tree_state(model, iTree, n_classes)
+    return backend.get_tree.classification.get_tree_state(model, iTree, n_classes)
 
 
 def get_tree_state_reg(model, iTree, n_classes):
-    return _backend.get_tree.regression.get_tree_state(model, iTree, n_classes)
+    return backend.get_tree.regression.get_tree_state(model, iTree, n_classes)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/primitives/kernel_functions.py

@@ -16,11 +16,13 @@
 
 import numpy as np
 
-from onedal import _backend
+from onedal import _default_backend as backend
+from onedal._device_offload import supports_queue
+from onedal.common._backend import BackendFunction
+from onedal.utils import _sycl_queue_manager as QM
 
-from ..common._policy import _get_policy
 from ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils.validation import _check_array
 
 
 def _check_inputs(X, Y):
@@ -32,14 +34,20 @@ def _check_inputs(X, Y):
     return X, Y
 
 
-def _compute_kernel(params, submodule, X, Y, queue):
-    policy = _get_policy(queue, X, Y)
+def _compute_kernel(params, submodule, X, Y):
+    # get policy for direct backend calls
+
+    queue = QM.get_global_queue()
     X, Y = to_table(X, Y, queue=queue)
     params["fptype"] = X.dtype
-    result = submodule.compute(policy, params, X, Y)
+    compute_method = BackendFunction(
+        submodule.compute, backend, "compute", no_policy=False
+    )
+    result = compute_method(params, X, Y)
     return from_table(result.values)
 
 
+@supports_queue
 def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
     """
     Compute the linear kernel between X and Y:
@@ -60,13 +68,13 @@ def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
     X, Y = _check_inputs(X, Y)
     return _compute_kernel(
         {"method": "dense", "scale": scale, "shift": shift},
-        _backend.linear_kernel,
+        backend.linear_kernel,
         X,
         Y,
-        queue,
     )
 
 
+@supports_queue
 def rbf_kernel(X, Y=None, gamma=None, queue=None):
     """
     Compute the rbf (gaussian) kernel between X and Y:
@@ -90,11 +98,10 @@ def rbf_kernel(X, Y=None, gamma=None, queue=None):
     gamma = 1.0 / X.shape[1] if gamma is None else gamma
     sigma = np.sqrt(0.5 / gamma)
 
-    return _compute_kernel(
-        {"method": "dense", "sigma": sigma}, _backend.rbf_kernel, X, Y, queue
-    )
+    return _compute_kernel({"method": "dense", "sigma": sigma}, backend.rbf_kernel, X, Y)
 
 
+@supports_queue
 def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
     """
     Compute the poly kernel between X and Y:
@@ -117,13 +124,13 @@ def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
     X, Y = _check_inputs(X, Y)
     return _compute_kernel(
         {"method": "dense", "scale": gamma, "shift": coef0, "degree": degree},
-        _backend.polynomial_kernel,
+        backend.polynomial_kernel,
         X,
         Y,
-        queue,
     )
 
 
+@supports_queue
 def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
     """
     Compute the sigmoid kernel between X and Y:
@@ -144,9 +151,5 @@ def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
 
     X, Y = _check_inputs(X, Y)
     return _compute_kernel(
-        {"method": "dense", "scale": gamma, "shift": coef0},
-        _backend.sigmoid_kernel,
-        X,
-        Y,
-        queue,
+        {"method": "dense", "scale": gamma, "shift": coef0}, backend.sigmoid_kernel, X, Y
     )

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/primitives/tests/test_kernel_functions.py

@@ -91,7 +91,7 @@ def test_dense_small_rbf_kernel(queue, gamma, dtype):
     _test_dense_small_rbf_kernel(queue, gamma, dtype)
 
 
-@pass_if_not_implemented_for_gpu(reason="poly kernel is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Polynomial kernel is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_dense_self_poly_kernel(queue):
     rng = np.random.RandomState(0)
@@ -116,7 +116,7 @@ def _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
     assert_allclose(result, expected, rtol=tol)
 
 
-@pass_if_not_implemented_for_gpu(reason="poly kernel is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Polynomial kernel is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("gamma", [0.1, 1.0])
 @pytest.mark.parametrize("coef0", [0.0, 1.0])
@@ -126,7 +126,7 @@ def test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
     _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype)
 
 
-@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Sigmoid kernel is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_dense_self_sigmoid_kernel(queue):
     rng = np.random.RandomState(0)
@@ -150,7 +150,7 @@ def _test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype):
     assert_allclose(result, expected, rtol=tol)
 
 
-@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Sigmoid kernel is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("gamma", [0.1, 1.0, 2.4])
 @pytest.mark.parametrize("coef0", [0.0, 1.0, 5.5])