scikit-learn-intelex 2023.2.1__py39-none-win_amd64.whl → 2024.0.1__py39-none-win_amd64.whl

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,31 +12,53 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#===============================================================================
-
-from daal4py.sklearn._utils import sklearn_check_version
-from ._common import BaseSVR
-from .._device_offload import dispatch, wrap_output_data
+# ==============================================================================
 
 from sklearn.svm import NuSVR as sklearn_NuSVR
 from sklearn.utils.validation import _deprecate_positional_args
+
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import NuSVR as onedal_NuSVR
 
+from .._device_offload import dispatch, wrap_output_data
+from ._common import BaseSVR
+
 
 class NuSVR(sklearn_NuSVR, BaseSVR):
     __doc__ = sklearn_NuSVR.__doc__
 
-    if sklearn_check_version('1.2'):
+    if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_NuSVR._parameter_constraints}
 
     @_deprecate_positional_args
-    def __init__(self, *, kernel='rbf', degree=3, gamma='scale',
-                 coef0=0.0, tol=1e-3, C=1.0, nu=0.5, shrinking=True,
-                 cache_size=200, verbose=False, max_iter=-1):
+    def __init__(
+        self,
+        *,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        tol=1e-3,
+        C=1.0,
+        nu=0.5,
+        shrinking=True,
+        cache_size=200,
+        verbose=False,
+        max_iter=-1,
+    ):
         super().__init__(
-            kernel=kernel, degree=degree, gamma=gamma, coef0=coef0, tol=tol, C=C, nu=nu,
-            shrinking=shrinking, cache_size=cache_size, verbose=verbose,
-            max_iter=max_iter)
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            nu=nu,
+            shrinking=shrinking,
+            cache_size=cache_size,
+            verbose=verbose,
+            max_iter=max_iter,
+        )
 
     def fit(self, X, y, sample_weight=None):
         """
@@ -76,10 +98,17 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
             self._validate_params()
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
-        dispatch(self, 'fit', {
-            'onedal': self.__class__._onedal_fit,
-            'sklearn': sklearn_NuSVR.fit,
-        }, X, y, sample_weight)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_NuSVR.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
         return self
 
     @wrap_output_data
@@ -102,23 +131,28 @@ class NuSVR(sklearn_NuSVR, BaseSVR):
         """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'predict', {
-            'onedal': self.__class__._onedal_predict,
-            'sklearn': sklearn_NuSVR.predict,
-        }, X)
+        return dispatch(
+            self,
+            "predict",
+            {
+                "onedal": self.__class__._onedal_predict,
+                "sklearn": sklearn_NuSVR.predict,
+            },
+            X,
+        )
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
-            'C': self.C,
-            'nu': self.nu,
-            'kernel': self.kernel,
-            'degree': self.degree,
-            'gamma': self.gamma,
-            'coef0': self.coef0,
-            'tol': self.tol,
-            'shrinking': self.shrinking,
-            'cache_size': self.cache_size,
-            'max_iter': self.max_iter,
+            "C": self.C,
+            "nu": self.nu,
+            "kernel": self.kernel,
+            "degree": self.degree,
+            "gamma": self.gamma,
+            "coef0": self.coef0,
+            "tol": self.tol,
+            "shrinking": self.shrinking,
+            "cache_size": self.cache_size,
+            "max_iter": self.max_iter,
         }
 
         self._onedal_estimator = onedal_NuSVR(**onedal_params)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,19 +12,21 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#===============================================================================
+# ==============================================================================
 
 import numpy as np
 from scipy import sparse as sp
+from sklearn.exceptions import NotFittedError
+from sklearn.svm import SVC as sklearn_SVC
+from sklearn.utils.validation import _deprecate_positional_args
+
+from daal4py.sklearn._utils import sklearn_check_version
 
-from daal4py.sklearn._utils import sklearn_check_version, PatchingConditionsChain
-from ._common import BaseSVC
 from .._device_offload import dispatch, wrap_output_data
+from .._utils import PatchingConditionsChain
+from ._common import BaseSVC
 
-from sklearn.svm import SVC as sklearn_SVC
-from sklearn.utils.validation import _deprecate_positional_args
-from sklearn.exceptions import NotFittedError
-if sklearn_check_version('1.0'):
+if sklearn_check_version("1.0"):
     from sklearn.utils.metaestimators import available_if
 
 from onedal.svm import SVC as onedal_SVC
@@ -33,21 +35,46 @@ from onedal.svm import SVC as onedal_SVC
 class SVC(sklearn_SVC, BaseSVC):
     __doc__ = sklearn_SVC.__doc__
 
-    if sklearn_check_version('1.2'):
+    if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_SVC._parameter_constraints}
 
     @_deprecate_positional_args
-    def __init__(self, *, C=1.0, kernel='rbf', degree=3, gamma='scale',
-                 coef0=0.0, shrinking=True, probability=False,
-                 tol=1e-3, cache_size=200, class_weight=None,
-                 verbose=False, max_iter=-1, decision_function_shape='ovr',
-                 break_ties=False, random_state=None):
+    def __init__(
+        self,
+        *,
+        C=1.0,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        break_ties=False,
+        random_state=None,
+    ):
         super().__init__(
-            C=C, kernel=kernel, degree=degree, gamma=gamma, coef0=coef0,
-            shrinking=shrinking, probability=probability, tol=tol, cache_size=cache_size,
-            class_weight=class_weight, verbose=verbose, max_iter=max_iter,
-            decision_function_shape=decision_function_shape, break_ties=break_ties,
-            random_state=random_state)
+            C=C,
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            shrinking=shrinking,
+            probability=probability,
+            tol=tol,
+            cache_size=cache_size,
+            class_weight=class_weight,
+            verbose=verbose,
+            max_iter=max_iter,
+            decision_function_shape=decision_function_shape,
+            break_ties=break_ties,
+            random_state=random_state,
+        )
 
     def fit(self, X, y, sample_weight=None):
         """
@@ -87,10 +114,17 @@ class SVC(sklearn_SVC, BaseSVC):
             self._validate_params()
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
-        dispatch(self, 'fit', {
-            'onedal': self.__class__._onedal_fit,
-            'sklearn': sklearn_SVC.fit,
-        }, X, y, sample_weight)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_SVC.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
         return self
 
     @wrap_output_data
@@ -113,12 +147,18 @@ class SVC(sklearn_SVC, BaseSVC):
         """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'predict', {
-            'onedal': self.__class__._onedal_predict,
-            'sklearn': sklearn_SVC.predict,
-        }, X)
+        return dispatch(
+            self,
+            "predict",
+            {
+                "onedal": self.__class__._onedal_predict,
+                "sklearn": sklearn_SVC.predict,
+            },
+            X,
+        )
+
+    if sklearn_check_version("1.0"):
 
-    if sklearn_check_version('1.0'):
         @available_if(sklearn_SVC._check_proba)
         def predict_proba(self, X):
             """
@@ -148,7 +188,9 @@ class SVC(sklearn_SVC, BaseSVC):
             datasets.
             """
             return self._predict_proba(X)
+
     else:
+
         @property
         def predict_proba(self):
             self._check_proba()
@@ -156,64 +198,79 @@ class SVC(sklearn_SVC, BaseSVC):
 
     @wrap_output_data
     def _predict_proba(self, X):
-        sklearn_pred_proba = (sklearn_SVC.predict_proba
-                              if sklearn_check_version("1.0")
-                              else sklearn_SVC._predict_proba)
-
-        return dispatch(self, 'predict_proba', {
-            'onedal': self.__class__._onedal_predict_proba,
-            'sklearn': sklearn_pred_proba,
-        }, X)
+        sklearn_pred_proba = (
+            sklearn_SVC.predict_proba
+            if sklearn_check_version("1.0")
+            else sklearn_SVC._predict_proba
+        )
+
+        return dispatch(
+            self,
+            "predict_proba",
+            {
+                "onedal": self.__class__._onedal_predict_proba,
+                "sklearn": sklearn_pred_proba,
+            },
+            X,
+        )
 
     @wrap_output_data
     def decision_function(self, X):
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'decision_function', {
-            'onedal': self.__class__._onedal_decision_function,
-            'sklearn': sklearn_SVC.decision_function,
-        }, X)
+        return dispatch(
+            self,
+            "decision_function",
+            {
+                "onedal": self.__class__._onedal_decision_function,
+                "sklearn": sklearn_SVC.decision_function,
+            },
+            X,
+        )
 
     def _onedal_gpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
         patching_status = PatchingConditionsChain(
-            f'sklearn.svm.{class_name}.{method_name}')
-        if method_name == 'fit':
-            if len(data) > 1:
-                self._class_count = len(np.unique(data[1]))
-            self._is_sparse = sp.isspmatrix(data[0])
-            patching_status.and_conditions([
-                (self.kernel in ['linear', 'rbf'],
-                 f'Kernel is "{self.kernel}" while '
-                 '"linear" and "rbf" are only supported on GPU.'),
-                (self.class_weight is None, 'Class weight is not supported on GPU.'),
-                (self._class_count == 2, 'Multiclassification is not supported on GPU.'),
-                (not self._is_sparse, 'Sparse input is not supported on GPU.')
-            ])
-            return patching_status.get_status(logs=True)
-        if method_name in ['predict', 'predict_proba', 'decision_function']:
-            patching_status.and_conditions([
-                (hasattr(self, '_onedal_estimator') and self._onedal_gpu_supported(
-                    'fit', *data),
-                 'oneDAL model was not trained on GPU.')
-            ])
-            return patching_status.get_status(logs=True)
-        raise RuntimeError(f'Unknown method {method_name} in {class_name}')
+            f"sklearn.svm.{class_name}.{method_name}"
+        )
+        if len(data) > 1:
+            self._class_count = len(np.unique(data[1]))
+        self._is_sparse = sp.isspmatrix(data[0])
+        conditions = [
+            (
+                self.kernel in ["linear", "rbf"],
+                f'Kernel is "{self.kernel}" while '
+                '"linear" and "rbf" are only supported on GPU.',
+            ),
+            (self.class_weight is None, "Class weight is not supported on GPU."),
+            (not self._is_sparse, "Sparse input is not supported on GPU."),
+            (self._class_count == 2, "Multiclassification is not supported on GPU."),
+        ]
+        if method_name == "fit":
+            patching_status.and_conditions(conditions)
+            return patching_status
+        if method_name in ["predict", "predict_proba", "decision_function"]:
+            conditions.append(
+                (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained")
+            )
+            patching_status.and_conditions(conditions)
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {class_name}")
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
-            'C': self.C,
-            'kernel': self.kernel,
-            'degree': self.degree,
-            'gamma': self.gamma,
-            'coef0': self.coef0,
-            'tol': self.tol,
-            'shrinking': self.shrinking,
-            'cache_size': self.cache_size,
-            'max_iter': self.max_iter,
-            'class_weight': self.class_weight,
-            'break_ties': self.break_ties,
-            'decision_function_shape': self.decision_function_shape,
+            "C": self.C,
+            "kernel": self.kernel,
+            "degree": self.degree,
+            "gamma": self.gamma,
+            "coef0": self.coef0,
+            "tol": self.tol,
+            "shrinking": self.shrinking,
+            "cache_size": self.cache_size,
+            "max_iter": self.max_iter,
+            "class_weight": self.class_weight,
+            "break_ties": self.break_ties,
+            "decision_function_shape": self.decision_function_shape,
         }
 
         self._onedal_estimator = onedal_SVC(**onedal_params)
@@ -227,15 +284,16 @@ class SVC(sklearn_SVC, BaseSVC):
         return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_predict_proba(self, X, queue=None):
-        if getattr(self, 'clf_prob', None) is None:
+        if getattr(self, "clf_prob", None) is None:
             raise NotFittedError(
-                "predict_proba is not available when fitted with probability=False")
-        from .._config import get_config, config_context
+                "predict_proba is not available when fitted with probability=False"
+            )
+        from .._config import config_context, get_config
 
         # We use stock metaestimators below, so the only way
         # to pass a queue is using config_context.
         cfg = get_config()
-        cfg['target_offload'] = queue
+        cfg["target_offload"] = queue
         with config_context(**cfg):
             return self.clf_prob.predict_proba(X)
 

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/svm/svr.py

@@ -1,4 +1,4 @@
-#===============================================================================
+# ==============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,31 +12,53 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#===============================================================================
-
-from daal4py.sklearn._utils import sklearn_check_version
-from ._common import BaseSVR
-from .._device_offload import dispatch, wrap_output_data
+# ==============================================================================
 
 from sklearn.svm import SVR as sklearn_SVR
 from sklearn.utils.validation import _deprecate_positional_args
+
+from daal4py.sklearn._utils import sklearn_check_version
 from onedal.svm import SVR as onedal_SVR
 
+from .._device_offload import dispatch, wrap_output_data
+from ._common import BaseSVR
+
 
 class SVR(sklearn_SVR, BaseSVR):
     __doc__ = sklearn_SVR.__doc__
 
-    if sklearn_check_version('1.2'):
+    if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {**sklearn_SVR._parameter_constraints}
 
     @_deprecate_positional_args
-    def __init__(self, *, kernel='rbf', degree=3, gamma='scale',
-                 coef0=0.0, tol=1e-3, C=1.0, epsilon=0.1, shrinking=True,
-                 cache_size=200, verbose=False, max_iter=-1):
+    def __init__(
+        self,
+        *,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        tol=1e-3,
+        C=1.0,
+        epsilon=0.1,
+        shrinking=True,
+        cache_size=200,
+        verbose=False,
+        max_iter=-1,
+    ):
         super().__init__(
-            kernel=kernel, degree=degree, gamma=gamma, coef0=coef0, tol=tol, C=C,
-            epsilon=epsilon, shrinking=shrinking, cache_size=cache_size, verbose=verbose,
-            max_iter=max_iter)
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            epsilon=epsilon,
+            shrinking=shrinking,
+            cache_size=cache_size,
+            verbose=verbose,
+            max_iter=max_iter,
+        )
 
     def fit(self, X, y, sample_weight=None):
         """
@@ -76,10 +98,17 @@ class SVR(sklearn_SVR, BaseSVR):
             self._validate_params()
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=True)
-        dispatch(self, 'fit', {
-            'onedal': self.__class__._onedal_fit,
-            'sklearn': sklearn_SVR.fit,
-        }, X, y, sample_weight)
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": sklearn_SVR.fit,
+            },
+            X,
+            y,
+            sample_weight,
+        )
 
         return self
 
@@ -103,23 +132,28 @@ class SVR(sklearn_SVR, BaseSVR):
         """
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
-        return dispatch(self, 'predict', {
-            'onedal': self.__class__._onedal_predict,
-            'sklearn': sklearn_SVR.predict,
-        }, X)
+        return dispatch(
+            self,
+            "predict",
+            {
+                "onedal": self.__class__._onedal_predict,
+                "sklearn": sklearn_SVR.predict,
+            },
+            X,
+        )
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
         onedal_params = {
-            'C': self.C,
-            'epsilon': self.epsilon,
-            'kernel': self.kernel,
-            'degree': self.degree,
-            'gamma': self.gamma,
-            'coef0': self.coef0,
-            'tol': self.tol,
-            'shrinking': self.shrinking,
-            'cache_size': self.cache_size,
-            'max_iter': self.max_iter,
+            "C": self.C,
+            "epsilon": self.epsilon,
+            "kernel": self.kernel,
+            "degree": self.degree,
+            "gamma": self.gamma,
+            "coef0": self.coef0,
+            "tol": self.tol,
+            "shrinking": self.shrinking,
+            "cache_size": self.cache_size,
+            "max_iter": self.max_iter,
         }
 
         self._onedal_estimator = onedal_SVR(**onedal_params)

scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/svm/tests/test_svm.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+# ===============================================================================
+# Copyright 2021 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+
+
+# TODO:
+# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
+def test_sklearnex_import_svc(dataframe, queue):
+    from sklearnex.svm import SVC
+
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    svc = SVC(kernel="linear").fit(X, y)
+    assert "daal4py" in svc.__module__ or "sklearnex" in svc.__module__
+    assert_allclose(_as_numpy(svc.dual_coef_), [[-0.25, 0.25]])
+    assert_allclose(_as_numpy(svc.support_), [1, 3])
+
+
+# TODO:
+# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
+def test_sklearnex_import_nusvc(dataframe, queue):
+    from sklearnex.svm import NuSVC
+
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    svc = NuSVC(kernel="linear").fit(X, y)
+    assert "daal4py" in svc.__module__ or "sklearnex" in svc.__module__
+    assert_allclose(
+        _as_numpy(svc.dual_coef_), [[-0.04761905, -0.0952381, 0.0952381, 0.04761905]]
+    )
+    assert_allclose(_as_numpy(svc.support_), [0, 1, 3, 4])
+
+
+# TODO:
+# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
+def test_sklearnex_import_svr(dataframe, queue):
+    from sklearnex.svm import SVR
+
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    svc = SVR(kernel="linear").fit(X, y)
+    assert "daal4py" in svc.__module__ or "sklearnex" in svc.__module__
+    assert_allclose(_as_numpy(svc.dual_coef_), [[-0.1, 0.1]])
+    assert_allclose(_as_numpy(svc.support_), [1, 3])
+
+
+# TODO:
+# investigate failure for `dpnp.ndarrays` and `dpctl.tensors` on `GPU`
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
+)
+def test_sklearnex_import_nusvr(dataframe, queue):
+    from sklearnex.svm import NuSVR
+
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [+1, +1], [+1, +2], [+2, +1]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    svc = NuSVR(kernel="linear", nu=0.9).fit(X, y)
+    assert "daal4py" in svc.__module__ or "sklearnex" in svc.__module__
+    assert_allclose(
+        _as_numpy(svc.dual_coef_), [[-1.0, 0.611111, 1.0, -0.611111]], rtol=1e-3
+    )
+    assert_allclose(_as_numpy(svc.support_), [1, 2, 3, 5])