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

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

@@ -20,13 +20,14 @@ from enum import Enum
 import numpy as np
 from scipy import sparse as sp
 
-from onedal import _backend
+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._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
-from ..common._policy import _get_policy
 from ..datatypes import from_table, to_table
-from ..utils import (
+from ..utils.validation import (
     _check_array,
     _check_n_features,
     _check_X_y,
@@ -84,6 +85,12 @@ class BaseSVM(metaclass=ABCMeta):
         self.algorithm = algorithm
         self.svm_type = svm_type
 
+    @abstractmethod
+    def train(self, *args, **kwargs): ...
+
+    @abstractmethod
+    def infer(self, *args, **kwargs): ...
+
     def _validate_targets(self, y, dtype):
         self.class_weight_ = None
         self.classes_ = None
@@ -114,7 +121,7 @@ class BaseSVM(metaclass=ABCMeta):
             "cache_size": self.cache_size,
         }
 
-    def _fit(self, X, y, sample_weight, module, queue):
+    def _fit(self, X, y, sample_weight):
         if hasattr(self, "decision_function_shape"):
             if self.decision_function_shape not in ("ovr", "ovo", None):
                 raise ValueError(
@@ -166,17 +173,15 @@ class BaseSVM(metaclass=ABCMeta):
                     _gamma = 1.0 / X.shape[1]
                 else:
                     raise ValueError(
-                        "When 'gamma' is a string, it should be either 'scale' or "
-                        "'auto'. Got '{}' instead.".format(self.gamma)
+                        f"When 'gamma' is a string, it should be either 'scale' or 'auto'. Got '{self.gamma}' instead."
                     )
             else:
                 _gamma = self.gamma
             self._scale_, self._sigma_ = _gamma, np.sqrt(0.5 / _gamma)
 
-        policy = _get_policy(queue, *data)
-        data = to_table(*data, queue=queue)
+        data = to_table(*data, queue=QM.get_global_queue())
         params = self._get_onedal_params(data[0])
-        result = module.train(policy, params, *data)
+        result = self.train(params, *data)
 
         if self._sparse:
             self.dual_coef_ = sp.csr_matrix(from_table(result.coeffs).T)
@@ -200,8 +205,8 @@ class BaseSVM(metaclass=ABCMeta):
         self._onedal_model = result.model
         return self
 
-    def _create_model(self, module):
-        m = module.model()
+    def _create_model(self):
+        m = self.model()
 
         m.support_vectors = to_table(self.support_vectors_)
         m.coeffs = to_table(self.dual_coef_.T)
@@ -211,14 +216,14 @@ class BaseSVM(metaclass=ABCMeta):
             m.first_class_response, m.second_class_response = 0, 1
         return m
 
-    def _predict(self, X, module, queue):
+    def _predict(self, X):
         _check_is_fitted(self)
         if self.break_ties and self.decision_function_shape == "ovo":
             raise ValueError(
                 "break_ties must be False when " "decision_function_shape is 'ovo'"
             )
 
-        if module in [_backend.svm.classification, _backend.svm.nu_classification]:
+        if isinstance(self, ClassifierMixin):
             sv = self.support_vectors_
             if not self._sparse and sv.size > 0 and self._n_support.sum() != sv.shape[0]:
                 raise ValueError(
@@ -252,15 +257,14 @@ class BaseSVM(metaclass=ABCMeta):
                     % type(self).__name__
                 )
 
-            policy = _get_policy(queue, X)
-            X = to_table(X, queue=queue)
+            X = to_table(X, queue=QM.get_global_queue())
             params = self._get_onedal_params(X)
 
             if hasattr(self, "_onedal_model"):
                 model = self._onedal_model
             else:
                 model = self._create_model(module)
-            result = module.infer(policy, params, model, X)
+            result = self.infer(params, model, X)
             y = from_table(result.responses)
         return y
 
@@ -283,7 +287,7 @@ class BaseSVM(metaclass=ABCMeta):
         )
         return votes + transformed_confidences
 
-    def _decision_function(self, X, module, queue):
+    def _decision_function(self, X):
         _check_is_fitted(self)
         X = _check_array(
             X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse="csr"
@@ -301,7 +305,7 @@ class BaseSVM(metaclass=ABCMeta):
                 % type(self).__name__
             )
 
-        if module in [_backend.svm.classification, _backend.svm.nu_classification]:
+        if isinstance(self, ClassifierMixin):
             sv = self.support_vectors_
             if not self._sparse and sv.size > 0 and self._n_support.sum() != sv.shape[0]:
                 raise ValueError(
@@ -309,15 +313,14 @@ class BaseSVM(metaclass=ABCMeta):
                     f"of {self.__class__.__name__} was altered"
                 )
 
-        policy = _get_policy(queue, X)
-        X = to_table(X, queue=queue)
+        X = to_table(X, queue=QM.get_global_queue())
         params = self._get_onedal_params(X)
 
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
             model = self._create_model(module)
-        result = module.infer(policy, params, model, X)
+        result = self.infer(params, model, X)
         decision_function = from_table(result.decision_function)
 
         if len(self.classes_) == 2:
@@ -372,11 +375,22 @@ class SVR(RegressorMixin, BaseSVM):
         )
         self.svm_type = SVMtype.epsilon_svr
 
+    @bind_default_backend("svm.regression")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.regression")
+    def infer(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.regression")
+    def model(self): ...
+
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return super()._fit(X, y, sample_weight, _backend.svm.regression, queue)
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        y = super()._predict(X, _backend.svm.regression, queue)
+        y = self._predict(X)
         return y.ravel()
 
 
@@ -424,23 +438,35 @@ class SVC(ClassifierMixin, BaseSVM):
         )
         self.svm_type = SVMtype.c_svc
 
+    @bind_default_backend("svm.classification")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.classification")
+    def infer(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.classification")
+    def model(self): ...
+
     def _validate_targets(self, y, dtype):
         y, self.class_weight_, self.classes_ = _validate_targets(
             y, self.class_weight, dtype
         )
         return y
 
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return super()._fit(X, y, sample_weight, _backend.svm.classification, queue)
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        y = super()._predict(X, _backend.svm.classification, queue)
+        y = self._predict(X)
         if len(self.classes_) == 2:
             y = y.ravel()
         return self.classes_.take(np.asarray(y, dtype=np.intp)).ravel()
 
+    @supports_queue
     def decision_function(self, X, queue=None):
-        return super()._decision_function(X, _backend.svm.classification, queue)
+        return self._decision_function(X)
 
 
 class NuSVR(RegressorMixin, BaseSVM):
@@ -485,12 +511,22 @@ class NuSVR(RegressorMixin, BaseSVM):
         )
         self.svm_type = SVMtype.nu_svr
 
+    @bind_default_backend("svm.nu_regression")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.nu_regression")
+    def infer(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.nu_regression")
+    def model(self): ...
+
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return super()._fit(X, y, sample_weight, _backend.svm.nu_regression, queue)
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        y = super()._predict(X, _backend.svm.nu_regression, queue)
-        return y.ravel()
+        return self._predict(X).ravel()
 
 
 class NuSVC(ClassifierMixin, BaseSVM):
@@ -537,20 +573,32 @@ class NuSVC(ClassifierMixin, BaseSVM):
         )
         self.svm_type = SVMtype.nu_svc
 
+    @bind_default_backend("svm.nu_classification")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.nu_classification")
+    def infer(self, *args, **kwargs): ...
+
+    @bind_default_backend("svm.nu_classification")
+    def model(self): ...
+
     def _validate_targets(self, y, dtype):
         y, self.class_weight_, self.classes_ = _validate_targets(
             y, self.class_weight, dtype
         )
         return y
 
+    @supports_queue
     def fit(self, X, y, sample_weight=None, queue=None):
-        return super()._fit(X, y, sample_weight, _backend.svm.nu_classification, queue)
+        return self._fit(X, y, sample_weight)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        y = super()._predict(X, _backend.svm.nu_classification, queue)
+        y = self._predict(X)
         if len(self.classes_) == 2:
             y = y.ravel()
         return self.classes_.take(np.asarray(y, dtype=np.intp)).ravel()
 
+    @supports_queue
     def decision_function(self, X, queue=None):
-        return super()._decision_function(X, _backend.svm.nu_classification, queue)
+        return self._decision_function(X)

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

@@ -74,7 +74,7 @@ def _test_simple_dataset(queue, kernel):
     check_svm_model_equal(queue, clf0, clf1, *dataset)
 
 
-@pass_if_not_implemented_for_gpu(reason="csr svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize(
     "queue",
     get_queues("cpu")
@@ -82,8 +82,7 @@ def _test_simple_dataset(queue, kernel):
         pytest.param(
             get_queues("gpu"),
             marks=pytest.mark.xfail(
-                reason="raises UnknownError instead of RuntimeError "
-                "with unimplemented message"
+                reason="raises UnknownError instead of RuntimeError with unimplemented message"
             ),
         )
     ],
@@ -103,7 +102,7 @@ def _test_binary_dataset(queue, kernel):
     check_svm_model_equal(queue, clf0, clf1, *dataset)
 
 
-@pass_if_not_implemented_for_gpu(reason="csr svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize(
     "queue",
     get_queues("cpu")
@@ -111,9 +110,11 @@ def _test_binary_dataset(queue, kernel):
         pytest.param(
             get_queues("gpu"),
             marks=pytest.mark.xfail(
-                reason="raises UnknownError for linear and rbf, "
-                "Unimplemented error with inconsistent error message "
-                "for poly and sigmoid"
+                reason=(
+                    "raises UnknownError for linear and rbf, "
+                    "Unimplemented error with inconsistent error message "
+                    "for poly and sigmoid"
+                )
             ),
         )
     ],
@@ -138,7 +139,7 @@ def _test_iris(queue, kernel):
     check_svm_model_equal(queue, clf0, clf1, *dataset, decimal=2)
 
 
-@pass_if_not_implemented_for_gpu(reason="csr svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
 def test_iris(queue, kernel):
@@ -158,7 +159,7 @@ def _test_diabetes(queue, kernel):
     check_svm_model_equal(queue, clf0, clf1, *dataset)
 
 
-@pass_if_not_implemented_for_gpu(reason="csr svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
 def test_diabetes(queue, kernel):

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

@@ -44,7 +44,7 @@ def _test_libsvm_parameters(queue, array_constr, dtype):
     assert_array_equal(clf.predict(X, queue=queue), y)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("array_constr", [np.array])
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
@@ -52,7 +52,7 @@ def test_libsvm_parameters(queue, array_constr, dtype):
     _test_libsvm_parameters(queue, array_constr, dtype)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_class_weight(queue):
     X = np.array([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]])
@@ -63,7 +63,7 @@ def test_class_weight(queue):
     assert_array_almost_equal(clf.predict(X, queue=queue), [2] * 6)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_sample_weight(queue):
     X = np.array([[-2, 0], [-1, -1], [0, -2], [0, 2], [1, 1], [2, 2]])
@@ -74,7 +74,7 @@ def test_sample_weight(queue):
     assert_array_almost_equal(clf.intercept_, [0.0])
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_decision_function(queue):
     X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]]
@@ -88,7 +88,7 @@ def test_decision_function(queue):
     assert_array_almost_equal(dec.ravel(), clf.decision_function(X, queue=queue))
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_iris(queue):
     iris = datasets.load_iris()
@@ -97,7 +97,7 @@ def test_iris(queue):
     assert_array_equal(clf.classes_, np.sort(clf.classes_))
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_decision_function_shape(queue):
     X, y = make_blobs(n_samples=80, centers=5, random_state=0)
@@ -114,7 +114,7 @@ def test_decision_function_shape(queue):
     #     SVC(decision_function_shape='bad').fit(X_train, y_train)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_pickle(queue):
     iris = datasets.load_iris()
@@ -146,7 +146,7 @@ def _test_cancer_rbf_compare_with_sklearn(queue, nu, gamma):
     assert abs(result - expected) < 1e-4
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("gamma", ["scale", "auto"])
 @pytest.mark.parametrize("nu", [0.25, 0.5])
@@ -169,7 +169,7 @@ def _test_cancer_linear_compare_with_sklearn(queue, nu):
     assert abs(result - expected) < 1e-3
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("nu", [0.25, 0.5])
 def test_cancer_linear_compare_with_sklearn(queue, nu):
@@ -191,7 +191,7 @@ def _test_cancer_poly_compare_with_sklearn(queue, params):
     assert abs(result - expected) < 1e-4
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvc is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize(
     "params",

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

@@ -30,7 +30,7 @@ from onedal.tests.utils._device_selection import (
 synth_params = {"n_samples": 500, "n_features": 100, "random_state": 42}
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_diabetes_simple(queue):
     diabetes = datasets.load_diabetes()
@@ -39,7 +39,7 @@ def test_diabetes_simple(queue):
     assert clf.score(diabetes.data, diabetes.target, queue=queue) > 0.02
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_input_format_for_diabetes(queue):
     diabetes = datasets.load_diabetes()
@@ -67,7 +67,7 @@ def test_input_format_for_diabetes(queue):
     assert_allclose(res_c_contiguous_numpy, res_f_contiguous_numpy)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_predict(queue):
     iris = datasets.load_iris()
@@ -105,7 +105,7 @@ def _test_diabetes_compare_with_sklearn(queue, kernel):
     assert_allclose(clf_sklearn.dual_coef_, clf_onedal.dual_coef_, atol=1e-2)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
 def test_diabetes_compare_with_sklearn(queue, kernel):
@@ -129,7 +129,7 @@ def _test_synth_rbf_compare_with_sklearn(queue, C, nu, gamma):
     assert abs(result - expected) < 1e-3
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("gamma", ["scale", "auto"])
 @pytest.mark.parametrize("C", [100.0, 1000.0])
@@ -155,7 +155,7 @@ def _test_synth_linear_compare_with_sklearn(queue, C, nu):
     assert abs(result - expected) < 1e-3
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("C", [0.001, 0.1])
 @pytest.mark.parametrize("nu", [0.25, 0.75])
@@ -178,7 +178,7 @@ def _test_synth_poly_compare_with_sklearn(queue, params):
     assert abs(result - expected) < 1e-3
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize(
     "params",
@@ -191,7 +191,7 @@ def test_synth_poly_compare_with_sklearn(queue, params):
     _test_synth_poly_compare_with_sklearn(queue, params)
 
 
-@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_pickle(queue):
     diabetes = datasets.load_diabetes()

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

@@ -67,7 +67,7 @@ def test_libsvm_parameters(queue, array_constr, dtype):
         pytest.param(
             get_queues("gpu"),
             marks=pytest.mark.xfail(
-                reason="class weights are not implemented " "but the error is not raised"
+                reason="class weights are not implemented but the error is not raised"
             ),
         )
     ],
@@ -106,7 +106,7 @@ def test_decision_function(queue):
     assert_array_almost_equal(dec.ravel(), clf.decision_function(X, queue=queue))
 
 
-@pass_if_not_implemented_for_gpu(reason="multiclass svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_iris(queue):
     iris = datasets.load_iris()
@@ -115,7 +115,7 @@ def test_iris(queue):
     assert_array_equal(clf.classes_, np.sort(clf.classes_))
 
 
-@pass_if_not_implemented_for_gpu(reason="multiclass svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_decision_function_shape(queue):
     X, y = make_blobs(n_samples=80, centers=5, random_state=0)
@@ -132,7 +132,7 @@ def test_decision_function_shape(queue):
         SVC(decision_function_shape="bad").fit(X_train, y_train, queue=queue)
 
 
-@pass_if_not_implemented_for_gpu(reason="multiclass svm is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize("queue", get_queues())
 def test_pickle(queue):
     iris = datasets.load_iris()
@@ -149,7 +149,7 @@ def test_pickle(queue):
     assert_array_equal(expected, result)
 
 
-@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pass_if_not_implemented_for_gpu(reason="not implemented")
 @pytest.mark.parametrize(
     "queue",
     get_queues("cpu")

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

@@ -30,7 +30,7 @@ from onedal.tests.utils._device_selection import (
 synth_params = {"n_samples": 500, "n_features": 100, "random_state": 42}
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_run_to_run_fit(queue):
     diabetes = datasets.load_diabetes()
@@ -45,7 +45,7 @@ def test_run_to_run_fit(queue):
         assert_allclose(clf_first.dual_coef_, clf.dual_coef_)
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_diabetes_simple(queue):
     diabetes = datasets.load_diabetes()
@@ -54,7 +54,7 @@ def test_diabetes_simple(queue):
     assert clf.score(diabetes.data, diabetes.target, queue=queue) > 0.02
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_input_format_for_diabetes(queue):
     diabetes = datasets.load_diabetes()
@@ -82,7 +82,7 @@ def test_input_format_for_diabetes(queue):
     assert_allclose(res_c_contiguous_numpy, res_f_contiguous_numpy)
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_predict(queue):
     iris = datasets.load_iris()
@@ -120,7 +120,7 @@ def _test_diabetes_compare_with_sklearn(queue, kernel):
     assert_allclose(clf_sklearn.dual_coef_, clf_onedal.dual_coef_, atol=1e-1)
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
 def test_diabetes_compare_with_sklearn(queue, kernel):
@@ -143,7 +143,7 @@ def _test_synth_rbf_compare_with_sklearn(queue, C, gamma):
     assert result > expected - 1e-5
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("gamma", ["scale", "auto"])
 @pytest.mark.parametrize("C", [100.0, 1000.0])
@@ -167,7 +167,7 @@ def _test_synth_linear_compare_with_sklearn(queue, C):
     assert result > expected - 1e-3
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("C", [0.001, 0.1])
 def test_synth_linear_compare_with_sklearn(queue, C):
@@ -188,7 +188,7 @@ def _test_synth_poly_compare_with_sklearn(queue, params):
     assert result > expected - 1e-5
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize(
     "params",
@@ -201,7 +201,7 @@ def test_synth_poly_compare_with_sklearn(queue, params):
     _test_synth_poly_compare_with_sklearn(queue, params)
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_sided_sample_weight(queue):
     clf = SVR(C=1e-2, kernel="linear")
@@ -225,7 +225,7 @@ def test_sided_sample_weight(queue):
     assert y_pred == pytest.approx(1.5)
 
 
-@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pass_if_not_implemented_for_gpu(reason="Regression SVM is not implemented for GPU")
 @pytest.mark.parametrize("queue", get_queues())
 def test_pickle(queue):
     diabetes = datasets.load_diabetes()

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

@@ -63,6 +63,8 @@ def get_memory_usm():
 
 
 def is_dpctl_device_available(targets):
+    if not isinstance(targets, (list, tuple)):
+        raise TypeError("`targets` should be a list or tuple of strings.")
     if dpctl_available:
         for device in targets:
             if device == "cpu" and not dpctl.has_cpu_devices():
@@ -73,18 +75,6 @@ def is_dpctl_device_available(targets):
     return False
 
 
-def device_type_to_str(queue):
-    if queue is None:
-        return "cpu"
-
-    if dpctl_available:
-        if queue.sycl_device.is_cpu:
-            return "cpu"
-        if queue.sycl_device.is_gpu:
-            return "gpu"
-    return "unknown"
-
-
 def pass_if_not_implemented_for_gpu(reason=""):
     assert reason
 
@@ -92,7 +82,7 @@ def pass_if_not_implemented_for_gpu(reason=""):
         @functools.wraps(test)
         def wrapper(queue, *args, **kwargs):
             if queue is not None and queue.sycl_device.is_gpu:
-                with pytest.raises(RuntimeError, match="is not implemented for GPU"):
+                with pytest.raises(RuntimeError, match=reason):
                     test(queue, *args, **kwargs)
             else:
                 test(queue, *args, **kwargs)