scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/svm/tests/test_csr_svm.py

@@ -0,0 +1,352 @@
+# ==============================================================================
+# 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_array_almost_equal, assert_array_equal
+from scipy import sparse as sp
+from sklearn import datasets
+from sklearn.datasets import make_classification
+
+from onedal.common._mixin import ClassifierMixin
+from onedal.svm import SVC, SVR
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+
+def check_svm_model_equal(
+    queue, dense_svm, sparse_svm, X_train, y_train, X_test, decimal=6
+):
+    dense_svm.fit(X_train.toarray(), y_train, queue=queue)
+    if sp.issparse(X_test):
+        X_test_dense = X_test.toarray()
+    else:
+        X_test_dense = X_test
+    sparse_svm.fit(X_train, y_train, queue=queue)
+    assert sp.issparse(sparse_svm.support_vectors_)
+    assert sp.issparse(sparse_svm.dual_coef_)
+    assert_array_almost_equal(
+        dense_svm.support_vectors_, sparse_svm.support_vectors_.toarray(), decimal
+    )
+    assert_array_almost_equal(
+        dense_svm.dual_coef_, sparse_svm.dual_coef_.toarray(), decimal
+    )
+    assert_array_almost_equal(dense_svm.support_, sparse_svm.support_)
+    assert_array_almost_equal(
+        dense_svm.predict(X_test_dense, queue=queue),
+        sparse_svm.predict(X_test, queue=queue),
+    )
+
+    if isinstance(dense_svm, ClassifierMixin) and isinstance(sparse_svm, ClassifierMixin):
+        assert_array_almost_equal(
+            dense_svm.decision_function(X_test_dense, queue=queue),
+            sparse_svm.decision_function(X_test, queue=queue),
+            decimal,
+        )
+
+
+def _test_simple_dataset(queue, kernel):
+    X = np.array([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]])
+    sparse_X = sp.lil_matrix(X)
+    Y = [1, 1, 1, 2, 2, 2]
+
+    X2 = np.array([[-1, -1], [2, 2], [3, 2]])
+    sparse_X2 = sp.dok_matrix(X2)
+
+    dataset = sparse_X, Y, sparse_X2
+    clf0 = SVC(kernel=kernel, gamma=1)
+    clf1 = SVC(kernel=kernel, gamma=1)
+    check_svm_model_equal(queue, clf0, clf1, *dataset)
+
+
+@pass_if_not_implemented_for_gpu(reason="not implemented")
+@pytest.mark.parametrize(
+    "queue",
+    get_queues("cpu")
+    + [
+        pytest.param(
+            get_queues("gpu"),
+            marks=pytest.mark.xfail(
+                reason="raises UnknownError instead of RuntimeError with unimplemented message"
+            ),
+        )
+    ],
+)
+@pytest.mark.parametrize("kernel", ["linear", "rbf"])
+def test_simple_dataset(queue, kernel):
+    _test_simple_dataset(queue, kernel)
+
+
+def _test_binary_dataset(queue, kernel):
+    X, y = make_classification(n_samples=80, n_features=20, n_classes=2, random_state=0)
+    sparse_X = sp.csr_matrix(X)
+
+    dataset = sparse_X, y, sparse_X
+    clf0 = SVC(kernel=kernel)
+    clf1 = SVC(kernel=kernel)
+    check_svm_model_equal(queue, clf0, clf1, *dataset)
+
+
+@pass_if_not_implemented_for_gpu(reason="not implemented")
+@pytest.mark.parametrize(
+    "queue",
+    get_queues("cpu")
+    + [
+        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"
+                )
+            ),
+        )
+    ],
+)
+@pytest.mark.parametrize("kernel", ["linear", "rbf", "poly", "sigmoid"])
+def test_binary_dataset(queue, kernel):
+    _test_binary_dataset(queue, kernel)
+
+
+def _test_iris(queue, kernel):
+    iris = datasets.load_iris()
+    rng = np.random.RandomState(0)
+    perm = rng.permutation(iris.target.size)
+    iris.data = iris.data[perm]
+    iris.target = iris.target[perm]
+    sparse_iris_data = sp.csr_matrix(iris.data)
+
+    dataset = sparse_iris_data, iris.target, sparse_iris_data
+
+    clf0 = SVC(kernel=kernel)
+    clf1 = SVC(kernel=kernel)
+    check_svm_model_equal(queue, clf0, clf1, *dataset, decimal=2)
+
+
+@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):
+    if kernel == "rbf":
+        pytest.skip("RBF CSR SVM test failing in 2025.0.")
+    _test_iris(queue, kernel)
+
+
+def _test_diabetes(queue, kernel):
+    diabetes = datasets.load_diabetes()
+
+    sparse_diabetes_data = sp.csr_matrix(diabetes.data)
+    dataset = sparse_diabetes_data, diabetes.target, sparse_diabetes_data
+
+    clf0 = SVR(kernel=kernel, C=0.1)
+    clf1 = SVR(kernel=kernel, C=0.1)
+    check_svm_model_equal(queue, clf0, clf1, *dataset)
+
+
+@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):
+    if kernel == "sigmoid":
+        pytest.skip("Sparse sigmoid kernel function is buggy.")
+    _test_diabetes(queue, kernel)
+
+
+@pass_if_not_implemented_for_gpu(reason="csr svm is not implemented")
+@pytest.mark.xfail(reason="Failed test. Need investigate")
+@pytest.mark.parametrize("queue", get_queues())
+def test_sparse_realdata(queue):
+    data = np.array([0.03771744, 0.1003567, 0.01174647, 0.027069])
+    indices = np.array([6, 5, 35, 31])
+    indptr = np.array(
+        [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            2,
+            4,
+            4,
+            4,
+        ]
+    )
+    X = sp.csr_matrix((data, indices, indptr))
+    y = np.array(
+        [
+            1.0,
+            0.0,
+            2.0,
+            2.0,
+            1.0,
+            1.0,
+            1.0,
+            2.0,
+            2.0,
+            0.0,
+            1.0,
+            2.0,
+            2.0,
+            0.0,
+            2.0,
+            0.0,
+            3.0,
+            0.0,
+            3.0,
+            0.0,
+            1.0,
+            1.0,
+            3.0,
+            2.0,
+            3.0,
+            2.0,
+            0.0,
+            3.0,
+            1.0,
+            0.0,
+            2.0,
+            1.0,
+            2.0,
+            0.0,
+            1.0,
+            0.0,
+            2.0,
+            3.0,
+            1.0,
+            3.0,
+            0.0,
+            1.0,
+            0.0,
+            0.0,
+            2.0,
+            0.0,
+            1.0,
+            2.0,
+            2.0,
+            2.0,
+            3.0,
+            2.0,
+            0.0,
+            3.0,
+            2.0,
+            1.0,
+            2.0,
+            3.0,
+            2.0,
+            2.0,
+            0.0,
+            1.0,
+            0.0,
+            1.0,
+            2.0,
+            3.0,
+            0.0,
+            0.0,
+            2.0,
+            2.0,
+            1.0,
+            3.0,
+            1.0,
+            1.0,
+            0.0,
+            1.0,
+            2.0,
+            1.0,
+            1.0,
+            3.0,
+        ]
+    )
+
+    clf = SVC(kernel="linear").fit(X.toarray(), y, queue=queue)
+    sp_clf = SVC(kernel="linear").fit(X, y, queue=queue)
+
+    assert_array_equal(clf.support_vectors_, sp_clf.support_vectors_.toarray())
+    assert_array_equal(clf.dual_coef_, sp_clf.dual_coef_.toarray())

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/svm/tests/test_nusvc.py

@@ -0,0 +1,204 @@
+# ==============================================================================
+# 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_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 sklearn.svm import NuSVC as SklearnNuSVC
+
+from onedal.svm import NuSVC
+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 = NuSVC(kernel="linear").fit(X, y, queue=queue)
+    assert_array_almost_equal(
+        clf.dual_coef_, [[-0.04761905, -0.0952381, 0.0952381, 0.04761905]]
+    )
+    assert_array_equal(clf.support_, [0, 1, 3, 4])
+    assert_array_equal(clf.support_vectors_, X[clf.support_])
+    assert_array_equal(clf.intercept_, [0.0])
+    assert_array_equal(clf.predict(X, queue=queue), y)
+
+
+@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])
+def test_libsvm_parameters(queue, array_constr, dtype):
+    _test_libsvm_parameters(queue, array_constr, dtype)
+
+
+@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]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+
+    clf = NuSVC(class_weight={1: 0.1})
+    clf.fit(X, y, queue=queue)
+    assert_array_almost_equal(clf.predict(X, queue=queue), [2] * 6)
+
+
+@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]])
+    y = np.array([1, 1, 1, 2, 2, 2])
+
+    clf = NuSVC(kernel="linear")
+    clf.fit(X, y, sample_weight=[1] * 6, queue=queue)
+    assert_array_almost_equal(clf.intercept_, [0.0])
+
+
+@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]]
+    Y = [1, 1, 1, 2, 2, 2]
+
+    clf = NuSVC(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="not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_iris(queue):
+    iris = datasets.load_iris()
+    clf = NuSVC(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="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 = NuSVC(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)
+
+
+@pass_if_not_implemented_for_gpu(reason="not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    iris = datasets.load_iris()
+    clf = NuSVC(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)
+
+
+def _test_cancer_rbf_compare_with_sklearn(queue, nu, gamma):
+    cancer = datasets.load_breast_cancer()
+
+    clf = NuSVC(kernel="rbf", gamma=gamma, nu=nu)
+    clf.fit(cancer.data, cancer.target, queue=queue)
+    result = clf.score(cancer.data, cancer.target, queue=queue)
+
+    clf = SklearnNuSVC(kernel="rbf", gamma=gamma, nu=nu)
+    clf.fit(cancer.data, cancer.target)
+    expected = clf.score(cancer.data, cancer.target)
+
+    assert result > 0.4
+    assert abs(result - expected) < 1e-4
+
+
+@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])
+def test_cancer_rbf_compare_with_sklearn(queue, nu, gamma):
+    _test_cancer_rbf_compare_with_sklearn(queue, nu, gamma)
+
+
+def _test_cancer_linear_compare_with_sklearn(queue, nu):
+    cancer = datasets.load_breast_cancer()
+
+    clf = NuSVC(kernel="linear", nu=nu)
+    clf.fit(cancer.data, cancer.target, queue=queue)
+    result = clf.score(cancer.data, cancer.target, queue=queue)
+
+    clf = SklearnNuSVC(kernel="linear", nu=nu)
+    clf.fit(cancer.data, cancer.target)
+    expected = clf.score(cancer.data, cancer.target)
+
+    assert result > 0.5
+    assert abs(result - expected) < 1e-3
+
+
+@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):
+    _test_cancer_linear_compare_with_sklearn(queue, nu)
+
+
+def _test_cancer_poly_compare_with_sklearn(queue, params):
+    cancer = datasets.load_breast_cancer()
+
+    clf = NuSVC(kernel="poly", **params)
+    clf.fit(cancer.data, cancer.target, queue=queue)
+    result = clf.score(cancer.data, cancer.target, queue=queue)
+
+    clf = SklearnNuSVC(kernel="poly", **params)
+    clf.fit(cancer.data, cancer.target)
+    expected = clf.score(cancer.data, cancer.target)
+
+    assert result > 0.5
+    assert abs(result - expected) < 1e-4
+
+
+@pass_if_not_implemented_for_gpu(reason="not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize(
+    "params",
+    [
+        {"degree": 2, "coef0": 0.1, "gamma": "scale", "nu": 0.25},
+        {"degree": 3, "coef0": 0.0, "gamma": "scale", "nu": 0.5},
+    ],
+)
+def test_cancer_poly_compare_with_sklearn(queue, params):
+    _test_cancer_poly_compare_with_sklearn(queue, params)