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/linear_model/tests/test_linear_regression.py

@@ -0,0 +1,252 @@
+# ===============================================================================
+# Copyright 2023 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_equal
+from sklearn.datasets import load_diabetes
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.linear_model import LinearRegression
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_diabetes(queue, dtype):
+    X, y = load_diabetes(return_X_y=True)
+    X, y = X.astype(dtype), y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, train_size=0.8, random_state=777
+    )
+    model = LinearRegression(fit_intercept=True)
+    model.fit(X_train, y_train, queue=queue)
+    y_pred = model.predict(X_test, queue=queue)
+    assert_allclose(mean_squared_error(y_test, y_pred), 2395.567, rtol=1e-5)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_pickle(queue, dtype):
+    X, y = load_diabetes(return_X_y=True)
+    X, y = X.astype(dtype), y.astype(dtype)
+    model = LinearRegression(fit_intercept=True)
+    model.fit(X, y, queue=queue)
+    expected = model.predict(X, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(model)
+    model2 = pickle.loads(dump)
+
+    assert isinstance(model2, model.__class__)
+    result = model2.predict(X, queue=queue)
+
+    assert_array_equal(expected, result)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_full_results(queue, dtype):
+    seed = 42
+    f_count, r_count = 19, 7
+    s_count, t_count = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    intp = gen.random(size=r_count, dtype=dtype)
+    coef = gen.random(size=(r_count, f_count), dtype=dtype).T
+
+    X = gen.random(size=(s_count, f_count), dtype=dtype)
+    y = X @ coef + intp[np.newaxis, :]
+
+    model = LinearRegression(fit_intercept=True)
+    model.fit(X, y, queue=queue)
+
+    if queue and queue.sycl_device.is_gpu:
+        tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
+    else:
+        tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-5
+    assert_allclose(coef, model.coef_.T, rtol=tol)
+
+    tol = 2e-3 if model.intercept_.dtype == np.float32 else 1e-5
+    assert_allclose(intp, model.intercept_, rtol=tol)
+
+    Xt = gen.random(size=(t_count, f_count), dtype=dtype)
+    gtr = Xt @ coef + intp[np.newaxis, :]
+
+    res = model.predict(Xt, queue=queue)
+
+    tol = 2e-4 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_no_intercept_results(queue, dtype):
+    seed = 42
+    f_count, r_count = 19, 7
+    s_count, t_count = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    coef = gen.random(size=(r_count, f_count), dtype=dtype).T
+
+    X = gen.random(size=(s_count, f_count), dtype=dtype)
+    y = X @ coef
+
+    model = LinearRegression(fit_intercept=False)
+    model.fit(X, y, queue=queue)
+
+    if queue and queue.sycl_device.is_gpu:
+        tol = 3e-3 if model.coef_.dtype == np.float32 else 1e-7
+    else:
+        tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-7
+    assert_allclose(coef, model.coef_.T, rtol=tol)
+
+    Xt = gen.random(size=(t_count, f_count), dtype=dtype)
+    gtr = Xt @ coef
+
+    res = model.predict(Xt, queue=queue)
+
+    tol = 5e-5 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_reconstruct_model(queue, dtype):
+    seed = 42
+    s_count = 3500
+    f_count, r_count = 14, 9
+
+    gen = np.random.default_rng(seed)
+    intp = gen.random(size=r_count, dtype=dtype)
+    coef = gen.random(size=(r_count, f_count), dtype=dtype).T
+
+    X = gen.random(size=(s_count, f_count), dtype=dtype)
+    gtr = X @ coef + intp[np.newaxis, :]
+
+    model = LinearRegression(fit_intercept=True)
+    model.coef_ = coef.T
+    model.intercept_ = intp
+
+    res = model.predict(X, queue=queue)
+
+    tol = 1e-5 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    reason="Functionality introduced in later versions",
+)
+def test_overdetermined_system(queue, dtype, fit_intercept):
+    if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
+        pytest.skip("Functionality introduced in later versions")
+    gen = np.random.default_rng(seed=123)
+    X = gen.standard_normal(size=(10, 20)).astype(dtype)
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ y
+        x = np.squeeze(model.coef_)
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ y
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    reason="Functionality introduced in later versions",
+)
+def test_singular_matrix(queue, dtype, fit_intercept):
+    if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
+        pytest.skip("Functionality introduced in later versions")
+    gen = np.random.default_rng(seed=123)
+    X = gen.standard_normal(size=(20, 4)).astype(dtype)
+    X[:, 2] = X[:, 3]
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ y
+        x = np.squeeze(model.coef_)
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ y
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("fit_intercept", [False, True])
+@pytest.mark.parametrize("problem_type", ["regular", "overdetermined", "singular"])
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 1)),
+    reason="Functionality introduced in the versions >= 2025.0",
+)
+def test_multioutput_regression(queue, dtype, fit_intercept, problem_type):
+    if (
+        problem_type != "regular"
+        and queue
+        and queue.sycl_device.is_gpu
+        and not daal_check_version((2025, "P", 200))
+    ):
+        pytest.skip("Functionality introduced in later versions")
+    gen = np.random.default_rng(seed=123)
+    if problem_type == "regular":
+        X = gen.standard_normal(size=(20, 5))
+    elif problem_type == "singular":
+        X = gen.standard_normal(size=(20, 4))
+        X[:, 3] = X[:, 2]
+    else:
+        X = gen.standard_normal(size=(10, 20))
+    Y = gen.standard_normal(size=(X.shape[0], 3), dtype=dtype)
+
+    model = LinearRegression(fit_intercept=fit_intercept).fit(X, Y)
+    if not fit_intercept:
+        A = X.T @ X
+        b = X.T @ Y
+        x = model.coef_.T
+    else:
+        Xi = np.c_[X, np.ones((X.shape[0], 1))]
+        A = Xi.T @ Xi
+        b = Xi.T @ Y
+        x = np.r_[model.coef_.T, model.intercept_.reshape((1, -1))]
+    residual = A @ x - b
+    assert np.all(np.abs(residual) < 1e-5)
+
+    pred = model.predict(X, queue=queue)
+    expected_pred = X @ model.coef_.T + model.intercept_.reshape((1, -1))
+    tol = 1e-5 if pred.dtype == np.float32 else 1e-7
+    assert_allclose(pred, expected_pred, rtol=tol)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/tests/test_logistic_regression.py

@@ -0,0 +1,95 @@
+# ===============================================================================
+# Copyright 2023 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.
+# ===============================================================================
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2024, "P", 1)):
+    import numpy as np
+    import pytest
+    from numpy.testing import assert_allclose, assert_array_equal
+    from scipy.sparse import csr_matrix
+    from sklearn.datasets import load_breast_cancer, make_classification
+    from sklearn.metrics import accuracy_score
+    from sklearn.model_selection import train_test_split
+
+    from onedal.linear_model import LogisticRegression
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues("gpu"))
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_breast_cancer(queue, dtype):
+        X, y = load_breast_cancer(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, train_size=0.8, random_state=42
+        )
+        model = LogisticRegression(fit_intercept=True, solver="newton-cg")
+        model.fit(X_train, y_train, queue=queue)
+        y_pred = model.predict(X_test, queue=queue)
+        assert accuracy_score(y_test, y_pred) > 0.95
+
+        assert hasattr(model, "n_iter_")
+        assert hasattr(model, "coef_")
+        assert hasattr(model, "intercept_")
+        if daal_check_version((2024, "P", 300)):
+            assert hasattr(model, "_n_inner_iter")
+
+    @pytest.mark.parametrize("queue", get_queues("gpu"))
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_pickle(queue, dtype):
+        X, y = load_breast_cancer(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        model = LogisticRegression(fit_intercept=True, solver="newton-cg")
+        model.fit(X, y, queue=queue)
+        expected = model.predict(X, queue=queue)
+
+        import pickle
+
+        dump = pickle.dumps(model)
+        model2 = pickle.loads(dump)
+
+        assert isinstance(model2, model.__class__)
+        result = model2.predict(X, queue=queue)
+
+        assert_array_equal(expected, result)
+
+
+if daal_check_version((2024, "P", 700)):
+
+    @pytest.mark.parametrize("queue", get_queues("gpu"))
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize(
+        "dims", [(3007, 17, 0.05), (50000, 100, 0.01), (512, 10, 0.5)]
+    )
+    def test_csr(queue, dtype, dims):
+        n, p, density = dims
+        X, y = make_classification(n, p, random_state=42)
+        np.random.seed(2007 + n + p)
+        mask = np.random.binomial(1, density, (n, p))
+        X = X * mask
+        X_sp = csr_matrix(X)
+        model = LogisticRegression(fit_intercept=True, solver="newton-cg")
+        model.fit(X, y, queue=queue)
+        pred = model.predict(X, queue=queue)
+
+        model_sp = LogisticRegression(fit_intercept=True, solver="newton-cg")
+        model_sp.fit(X_sp, y, queue=queue)
+        pred_sp = model_sp.predict(X_sp, queue=queue)
+
+        rtol = 2e-4
+        assert_allclose(pred, pred_sp, rtol=rtol)
+        assert_allclose(model.coef_, model_sp.coef_, rtol=rtol)
+        assert_allclose(model.intercept_, model_sp.intercept_, rtol=rtol)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/tests/test_ridge.py

@@ -0,0 +1,95 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2024, "P", 600)):
+    import numpy as np
+    import pytest
+    from numpy.testing import assert_allclose, assert_array_equal
+    from sklearn.datasets import load_diabetes
+    from sklearn.metrics import mean_squared_error
+    from sklearn.model_selection import train_test_split
+
+    from onedal.linear_model import Ridge
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_diabetes(queue, dtype):
+        X, y = load_diabetes(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, train_size=0.8, random_state=777
+        )
+        model = Ridge(fit_intercept=True, alpha=0.1)
+        model.fit(X_train, y_train, queue=queue)
+        y_pred = model.predict(X_test, queue=queue)
+        assert_allclose(mean_squared_error(y_test, y_pred), 2388.775, rtol=1e-5)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_pickle(queue, dtype):
+        X, y = load_diabetes(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        model = Ridge(fit_intercept=True, alpha=0.5)
+        model.fit(X, y, queue=queue)
+        expected = model.predict(X, queue=queue)
+
+        import pickle
+
+        dump = pickle.dumps(model)
+        model2 = pickle.loads(dump)
+
+        assert isinstance(model2, model.__class__)
+        result = model2.predict(X, queue=queue)
+
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_no_intercept_results(queue, dtype):
+        seed = 42
+        n_features, n_targets = 19, 7
+        n_train_samples, n_test_samples = 3500, 1999
+
+        gen = np.random.default_rng(seed)
+
+        X = gen.random(size=(n_train_samples, n_features), dtype=dtype)
+        y = gen.random(size=(n_train_samples, n_targets), dtype=dtype)
+        alpha = 0.5
+
+        lambda_identity = alpha * np.eye(X.shape[1])
+        inverse_term = np.linalg.inv(np.dot(X.T, X) + lambda_identity)
+        xt_y = np.dot(X.T, y)
+        coef = np.dot(inverse_term, xt_y)
+
+        model = Ridge(fit_intercept=False, alpha=alpha)
+        model.fit(X, y, queue=queue)
+
+        if queue and queue.sycl_device.is_gpu:
+            tol = 5e-3 if model.coef_.dtype == np.float32 else 1e-5
+        else:
+            tol = 2e-3 if model.coef_.dtype == np.float32 else 1e-5
+        assert_allclose(coef, model.coef_.T, rtol=tol)
+
+        Xt = gen.random(size=(n_test_samples, n_features), dtype=dtype)
+        gtr = Xt @ coef
+
+        res = model.predict(Xt, queue=queue)
+
+        tol = 2e-4 if res.dtype == np.float32 else 1e-7
+        assert_allclose(gtr, res, rtol=tol)

{scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/spmd → scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal}/neighbors/__init__.py

@@ -1,19 +1,19 @@
-# ==============================================================================
-# Copyright 2023 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.
-# ==============================================================================
-
-from .neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors
-
-__all__ = ["KNeighborsClassifier", "KNeighborsRegressor", "NearestNeighbors"]
+# ===============================================================================
+# Copyright 2022 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.
+# ===============================================================================
+
+from .neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors
+
+__all__ = ["KNeighborsClassifier", "KNeighborsRegressor", "NearestNeighbors"]