scikit-learn-intelex 2025.0.0__py312-none-manylinux_2_28_x86_64.whl

onedal/svm/tests/test_nusvr.py

@@ -0,0 +1,210 @@
+# ==============================================================================
+# 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, assert_array_almost_equal, assert_array_equal
+from sklearn import datasets
+from sklearn.metrics.pairwise import rbf_kernel
+from sklearn.svm import NuSVR as SklearnNuSVR
+
+from onedal.svm import NuSVR
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+synth_params = {"n_samples": 500, "n_features": 100, "random_state": 42}
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_diabetes_simple(queue):
+    diabetes = datasets.load_diabetes()
+    clf = NuSVR(kernel="linear", C=10.0)
+    clf.fit(diabetes.data, diabetes.target, queue=queue)
+    assert clf.score(diabetes.data, diabetes.target, queue=queue) > 0.02
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_input_format_for_diabetes(queue):
+    diabetes = datasets.load_diabetes()
+
+    c_contiguous_numpy = np.asanyarray(diabetes.data, dtype="float", order="C")
+    assert c_contiguous_numpy.flags.c_contiguous
+    assert not c_contiguous_numpy.flags.f_contiguous
+    assert not c_contiguous_numpy.flags.fnc
+
+    clf = NuSVR(kernel="linear", C=10.0)
+    clf.fit(c_contiguous_numpy, diabetes.target, queue=queue)
+    dual_c_contiguous_numpy = clf.dual_coef_
+    res_c_contiguous_numpy = clf.predict(c_contiguous_numpy, queue=queue)
+
+    f_contiguous_numpy = np.asanyarray(diabetes.data, dtype="float", order="F")
+    assert not f_contiguous_numpy.flags.c_contiguous
+    assert f_contiguous_numpy.flags.f_contiguous
+    assert f_contiguous_numpy.flags.fnc
+
+    clf = NuSVR(kernel="linear", C=10.0)
+    clf.fit(f_contiguous_numpy, diabetes.target, queue=queue)
+    dual_f_contiguous_numpy = clf.dual_coef_
+    res_f_contiguous_numpy = clf.predict(f_contiguous_numpy, queue=queue)
+    assert_allclose(dual_c_contiguous_numpy, dual_f_contiguous_numpy)
+    assert_allclose(res_c_contiguous_numpy, res_f_contiguous_numpy)
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_predict(queue):
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    reg = NuSVR(kernel="linear", C=0.1).fit(X, y, queue=queue)
+
+    linear = np.dot(X, reg.support_vectors_.T)
+    dec = np.dot(linear, reg.dual_coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X, queue=queue).ravel())
+
+    reg = NuSVR(kernel="rbf", gamma=1).fit(X, y, queue=queue)
+
+    rbfs = rbf_kernel(X, reg.support_vectors_, gamma=reg.gamma)
+    dec = np.dot(rbfs, reg.dual_coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X, queue=queue).ravel())
+
+
+def _test_diabetes_compare_with_sklearn(queue, kernel):
+    diabetes = datasets.load_diabetes()
+    clf_onedal = NuSVR(kernel=kernel, nu=0.25, C=10.0)
+    clf_onedal.fit(diabetes.data, diabetes.target, queue=queue)
+    result = clf_onedal.score(diabetes.data, diabetes.target, queue=queue)
+
+    clf_sklearn = SklearnNuSVR(kernel=kernel, nu=0.25, C=10.0)
+    clf_sklearn.fit(diabetes.data, diabetes.target)
+    expected = clf_sklearn.score(diabetes.data, diabetes.target)
+
+    assert result > expected - 1e-5
+    assert_allclose(clf_sklearn.intercept_, clf_onedal.intercept_, atol=1e-3)
+    assert_allclose(
+        clf_sklearn.support_vectors_.shape, clf_sklearn.support_vectors_.shape
+    )
+    assert_allclose(clf_sklearn.dual_coef_, clf_onedal.dual_coef_, atol=1e-2)
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
+def test_diabetes_compare_with_sklearn(queue, kernel):
+    if kernel == "sigmoid":
+        pytest.skip("Sparse sigmoid kernel function is buggy.")
+    _test_diabetes_compare_with_sklearn(queue, kernel)
+
+
+def _test_synth_rbf_compare_with_sklearn(queue, C, nu, gamma):
+    x, y = datasets.make_regression(**synth_params)
+
+    clf = NuSVR(kernel="rbf", gamma=gamma, C=C, nu=nu)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnNuSVR(kernel="rbf", gamma=gamma, C=C, nu=nu)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    assert result > 0.4
+    assert abs(result - expected) < 1e-3
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", ["scale", "auto"])
+@pytest.mark.parametrize("C", [100.0, 1000.0])
+@pytest.mark.parametrize("nu", [0.25, 0.75])
+def test_synth_rbf_compare_with_sklearn(queue, C, nu, gamma):
+    _test_synth_rbf_compare_with_sklearn(queue, C, nu, gamma)
+
+
+def _test_synth_linear_compare_with_sklearn(queue, C, nu):
+    x, y = datasets.make_regression(**synth_params)
+
+    clf = NuSVR(kernel="linear", C=C, nu=nu)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnNuSVR(kernel="linear", C=C, nu=nu)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    # Linear kernel doesn't work well for synthetic regression
+    # resulting in low R2 score
+    # assert result > 0.5
+    assert abs(result - expected) < 1e-3
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("C", [0.001, 0.1])
+@pytest.mark.parametrize("nu", [0.25, 0.75])
+def test_synth_linear_compare_with_sklearn(queue, C, nu):
+    _test_synth_linear_compare_with_sklearn(queue, C, nu)
+
+
+def _test_synth_poly_compare_with_sklearn(queue, params):
+    x, y = datasets.make_regression(**synth_params)
+
+    clf = NuSVR(kernel="poly", **params)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnNuSVR(kernel="poly", **params)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    assert result > 0.5
+    assert abs(result - expected) < 1e-3
+
+
+@pass_if_not_implemented_for_gpu(reason="nusvr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize(
+    "params",
+    [
+        {"degree": 2, "coef0": 0.1, "gamma": "scale", "C": 100, "nu": 0.25},
+        {"degree": 3, "coef0": 0.0, "gamma": "scale", "C": 1000, "nu": 0.75},
+    ],
+)
+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")
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    diabetes = datasets.load_diabetes()
+
+    clf = NuSVR(kernel="rbf", C=10.0)
+    clf.fit(diabetes.data, diabetes.target, queue=queue)
+    expected = clf.predict(diabetes.data, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(clf)
+    clf2 = pickle.loads(dump)
+
+    assert type(clf2) == clf.__class__
+    result = clf2.predict(diabetes.data, queue=queue)
+    assert_array_equal(expected, result)

onedal/svm/tests/test_svc.py

@@ -0,0 +1,168 @@
+# ==============================================================================
+# 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
+import sklearn.utils.estimator_checks
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+from sklearn import datasets
+from sklearn.datasets import make_blobs
+from sklearn.metrics.pairwise import rbf_kernel
+from sklearn.model_selection import train_test_split
+
+from onedal.svm import SVC
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+
+def _test_libsvm_parameters(queue, array_constr, dtype):
+    X = array_constr([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]], dtype=dtype)
+    y = array_constr([1, 1, 1, 2, 2, 2], dtype=dtype)
+
+    clf = SVC(kernel="linear").fit(X, y, queue=queue)
+    assert_array_equal(clf.dual_coef_, [[-0.25, 0.25]])
+    assert_array_equal(clf.support_, [1, 3])
+    assert_array_equal(clf.support_vectors_, (X[1], X[3]))
+    assert_array_equal(clf.intercept_, [0.0])
+    assert_array_equal(clf.predict(X), y)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("array_constr", [np.array])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_libsvm_parameters(queue, array_constr, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    _test_libsvm_parameters(queue, array_constr, dtype)
+
+
+@pass_if_not_implemented_for_gpu(reason="class weights are not implemented")
+@pytest.mark.parametrize(
+    "queue",
+    get_queues("cpu")
+    + [
+        pytest.param(
+            get_queues("gpu"),
+            marks=pytest.mark.xfail(
+                reason="class weights are not implemented " "but the error is not raised"
+            ),
+        )
+    ],
+)
+def test_class_weight(queue):
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+
+    clf = SVC(class_weight={1: 0.1})
+    clf.fit(X, y, queue=queue)
+    assert_array_almost_equal(clf.predict(X, queue=queue), [2] * 6)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_sample_weight(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Sporadic failures on GPU sycl_queue.")
+    X = np.array([[-2, 0], [-1, -1], [0, -2], [0, 2], [1, 1], [2, 2]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+
+    clf = SVC(kernel="linear")
+    clf.fit(X, y, sample_weight=[1] * 6, queue=queue)
+    assert_array_almost_equal(clf.intercept_, [0.0])
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_decision_function(queue):
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]], dtype=np.float32)
+    Y = np.array([1, 1, 1, 2, 2, 2], dtype=np.float32)
+
+    clf = SVC(kernel="rbf", gamma=1, decision_function_shape="ovo")
+    clf.fit(X, Y, queue=queue)
+
+    rbfs = rbf_kernel(X, clf.support_vectors_, gamma=clf.gamma)
+    dec = np.dot(rbfs, clf.dual_coef_.T) + clf.intercept_
+    assert_array_almost_equal(dec.ravel(), clf.decision_function(X, queue=queue))
+
+
+@pass_if_not_implemented_for_gpu(reason="multiclass svm is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_iris(queue):
+    iris = datasets.load_iris()
+    clf = SVC(kernel="linear").fit(iris.data, iris.target, queue=queue)
+    assert clf.score(iris.data, iris.target, queue=queue) > 0.9
+    assert_array_equal(clf.classes_, np.sort(clf.classes_))
+
+
+@pass_if_not_implemented_for_gpu(reason="multiclass svm is 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)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
+
+    # check shape of ovo_decition_function=True
+    clf = SVC(kernel="linear", decision_function_shape="ovo").fit(
+        X_train, y_train, queue=queue
+    )
+    dec = clf.decision_function(X_train, queue=queue)
+    assert dec.shape == (len(X_train), 10)
+
+    with pytest.raises(ValueError, match="must be either 'ovr' or 'ovo'"):
+        SVC(decision_function_shape="bad").fit(X_train, y_train, queue=queue)
+
+
+@pass_if_not_implemented_for_gpu(reason="multiclass svm is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    iris = datasets.load_iris()
+    clf = SVC(kernel="linear").fit(iris.data, iris.target, queue=queue)
+    expected = clf.decision_function(iris.data, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(clf)
+    clf2 = pickle.loads(dump)
+
+    assert type(clf2) == clf.__class__
+    result = clf2.decision_function(iris.data, queue=queue)
+    assert_array_equal(expected, result)
+
+
+@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pytest.mark.parametrize(
+    "queue",
+    get_queues("cpu")
+    + [
+        pytest.param(
+            get_queues("gpu"),
+            marks=pytest.mark.xfail(
+                reason="raises Unimplemented error " "with inconsistent error message"
+            ),
+        )
+    ],
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_svc_sigmoid(queue, dtype):
+    X_train = np.array(
+        [[-1, 2], [0, 0], [2, -1], [+1, +1], [+1, +2], [+2, +1]], dtype=dtype
+    )
+    X_test = np.array([[0, 2], [0.5, 0.5], [0.3, 0.1], [2, 0], [-1, -1]], dtype=dtype)
+    y_train = np.array([1, 1, 1, 2, 2, 2], dtype=dtype)
+    svc = SVC(kernel="sigmoid").fit(X_train, y_train, queue=queue)
+
+    assert_array_equal(svc.dual_coef_, [[-1, -1, -1, 1, 1, 1]])
+    assert_array_equal(svc.support_, [0, 1, 2, 3, 4, 5])
+    assert_array_equal(svc.predict(X_test, queue=queue), [2, 2, 1, 2, 1])

onedal/svm/tests/test_svr.py

@@ -0,0 +1,243 @@
+# ==============================================================================
+# 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, assert_array_almost_equal, assert_array_equal
+from sklearn import datasets
+from sklearn.metrics.pairwise import rbf_kernel
+from sklearn.svm import SVR as SklearnSVR
+
+from onedal.svm import SVR
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+synth_params = {"n_samples": 500, "n_features": 100, "random_state": 42}
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_run_to_run_fit(queue):
+    diabetes = datasets.load_diabetes()
+    clf_first = SVR(kernel="linear", C=10.0)
+    clf_first.fit(diabetes.data, diabetes.target, queue=queue)
+
+    for _ in range(10):
+        clf = SVR(kernel="linear", C=10.0)
+        clf.fit(diabetes.data, diabetes.target, queue=queue)
+        assert_allclose(clf_first.intercept_, clf.intercept_)
+        assert_allclose(clf_first.support_vectors_, clf.support_vectors_)
+        assert_allclose(clf_first.dual_coef_, clf.dual_coef_)
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_diabetes_simple(queue):
+    diabetes = datasets.load_diabetes()
+    clf = SVR(kernel="linear", C=10.0)
+    clf.fit(diabetes.data, diabetes.target, queue=queue)
+    assert clf.score(diabetes.data, diabetes.target, queue=queue) > 0.02
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_input_format_for_diabetes(queue):
+    diabetes = datasets.load_diabetes()
+
+    c_contiguous_numpy = np.asanyarray(diabetes.data, dtype="float", order="C")
+    assert c_contiguous_numpy.flags.c_contiguous
+    assert not c_contiguous_numpy.flags.f_contiguous
+    assert not c_contiguous_numpy.flags.fnc
+
+    clf = SVR(kernel="linear", C=10.0)
+    clf.fit(c_contiguous_numpy, diabetes.target, queue=queue)
+    dual_c_contiguous_numpy = clf.dual_coef_
+    res_c_contiguous_numpy = clf.predict(c_contiguous_numpy, queue=queue)
+
+    f_contiguous_numpy = np.asanyarray(diabetes.data, dtype="float", order="F")
+    assert not f_contiguous_numpy.flags.c_contiguous
+    assert f_contiguous_numpy.flags.f_contiguous
+    assert f_contiguous_numpy.flags.fnc
+
+    clf = SVR(kernel="linear", C=10.0)
+    clf.fit(f_contiguous_numpy, diabetes.target, queue=queue)
+    dual_f_contiguous_numpy = clf.dual_coef_
+    res_f_contiguous_numpy = clf.predict(f_contiguous_numpy, queue=queue)
+    assert_allclose(dual_c_contiguous_numpy, dual_f_contiguous_numpy)
+    assert_allclose(res_c_contiguous_numpy, res_f_contiguous_numpy)
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_predict(queue):
+    iris = datasets.load_iris()
+    X = iris.data
+    y = iris.target
+
+    reg = SVR(kernel="linear", C=0.1).fit(X, y, queue=queue)
+
+    linear = np.dot(X, reg.support_vectors_.T)
+    dec = np.dot(linear, reg.dual_coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X, queue=queue).ravel())
+
+    reg = SVR(kernel="rbf", gamma=1).fit(X, y, queue=queue)
+
+    rbfs = rbf_kernel(X, reg.support_vectors_, gamma=reg.gamma)
+    dec = np.dot(rbfs, reg.dual_coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X, queue=queue).ravel())
+
+
+def _test_diabetes_compare_with_sklearn(queue, kernel):
+    diabetes = datasets.load_diabetes()
+    clf_onedal = SVR(kernel=kernel, C=10.0, gamma=2)
+    clf_onedal.fit(diabetes.data, diabetes.target, queue=queue)
+    result = clf_onedal.score(diabetes.data, diabetes.target, queue=queue)
+
+    clf_sklearn = SklearnSVR(kernel=kernel, C=10.0, gamma=2)
+    clf_sklearn.fit(diabetes.data, diabetes.target)
+    expected = clf_sklearn.score(diabetes.data, diabetes.target)
+
+    assert result > expected - 1e-5
+    assert_allclose(clf_sklearn.intercept_, clf_onedal.intercept_, atol=1e-3)
+    assert_allclose(
+        clf_sklearn.support_vectors_.shape, clf_sklearn.support_vectors_.shape
+    )
+    assert_allclose(clf_sklearn.dual_coef_, clf_onedal.dual_coef_, atol=1e-1)
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
+def test_diabetes_compare_with_sklearn(queue, kernel):
+    if kernel == "sigmoid":
+        pytest.skip("Sparse sigmoid kernel function is buggy.")
+    _test_diabetes_compare_with_sklearn(queue, kernel)
+
+
+def _test_synth_rbf_compare_with_sklearn(queue, C, gamma):
+    x, y = datasets.make_regression(**synth_params)
+    clf = SVR(kernel="rbf", gamma=gamma, C=C)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnSVR(kernel="rbf", gamma=gamma, C=C)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    assert result > 0.4
+    assert result > expected - 1e-5
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", ["scale", "auto"])
+@pytest.mark.parametrize("C", [100.0, 1000.0])
+def test_synth_rbf_compare_with_sklearn(queue, C, gamma):
+    _test_synth_rbf_compare_with_sklearn(queue, C, gamma)
+
+
+def _test_synth_linear_compare_with_sklearn(queue, C):
+    x, y = datasets.make_regression(**synth_params)
+    clf = SVR(kernel="linear", C=C)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnSVR(kernel="linear", C=C)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    # Linear kernel doesn't work well for synthetic regression
+    # resulting in low R2 score
+    # assert result > 0.5
+    assert result > expected - 1e-3
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("C", [0.001, 0.1])
+def test_synth_linear_compare_with_sklearn(queue, C):
+    _test_synth_linear_compare_with_sklearn(queue, C)
+
+
+def _test_synth_poly_compare_with_sklearn(queue, params):
+    x, y = datasets.make_regression(**synth_params)
+    clf = SVR(kernel="poly", **params)
+    clf.fit(x, y, queue=queue)
+    result = clf.score(x, y, queue=queue)
+
+    clf = SklearnSVR(kernel="poly", **params)
+    clf.fit(x, y)
+    expected = clf.score(x, y)
+
+    assert result > 0.5
+    assert result > expected - 1e-5
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize(
+    "params",
+    [
+        {"degree": 2, "coef0": 0.1, "gamma": "scale", "C": 100},
+        {"degree": 3, "coef0": 0.0, "gamma": "scale", "C": 1000},
+    ],
+)
+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")
+@pytest.mark.parametrize("queue", get_queues())
+def test_sided_sample_weight(queue):
+    clf = SVR(C=1e-2, kernel="linear")
+
+    X = [[-2, 0], [-1, -1], [0, -2], [0, 2], [1, 1], [2, 0]]
+    Y = [1, 1, 1, 2, 2, 2]
+
+    sample_weight = [10.0, 0.1, 0.1, 0.1, 0.1, 10]
+    clf.fit(X, Y, sample_weight=sample_weight, queue=queue)
+    y_pred = clf.predict([[-1.0, 1.0]], queue=queue)
+    assert y_pred < 1.5
+
+    sample_weight = [1.0, 0.1, 10.0, 10.0, 0.1, 0.1]
+    clf.fit(X, Y, sample_weight=sample_weight, queue=queue)
+    y_pred = clf.predict([[-1.0, 1.0]], queue=queue)
+    assert y_pred > 1.5
+
+    sample_weight = [1] * 6
+    clf.fit(X, Y, sample_weight=sample_weight, queue=queue)
+    y_pred = clf.predict([[-1.0, 1.0]], queue=queue)
+    assert y_pred == pytest.approx(1.5)
+
+
+@pass_if_not_implemented_for_gpu(reason="svr is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    diabetes = datasets.load_diabetes()
+    clf = SVR(kernel="rbf", C=10.0)
+    clf.fit(diabetes.data, diabetes.target, queue=queue)
+    expected = clf.predict(diabetes.data, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(clf)
+    clf2 = pickle.loads(dump)
+
+    assert type(clf2) == clf.__class__
+    result = clf2.predict(diabetes.data, queue=queue)
+    assert_array_equal(expected, result)

onedal/tests/test_common.py

@@ -0,0 +1,41 @@
+# ==============================================================================
+# Copyright 2024 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 os
+from glob import glob
+
+import pytest
+
+
+def test_sklearn_check_version_ban():
+    """This test blocks the use of sklearn_check_version
+    in onedal files. The versioning should occur in the
+    sklearnex package for clarity and maintainability.
+    """
+    from onedal import __file__ as loc
+
+    path = loc.replace("__init__.py", "")
+    files = [y for x in os.walk(path) for y in glob(os.path.join(x[0], "*.py"))]
+
+    output = []
+
+    for f in files:
+        if open(f, "r").read().find("sklearn_check_version") != -1:
+            output += [f.replace(path, "onedal" + os.sep)]
+
+    # remove this file from the list
+    output = "\n".join([i for i in output if "test_common.py" not in i])
+    assert output == "", f"sklearn versioning is occuring in: \n{output}"