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

onedal/linear_model/tests/test_incremental_linear_regression.py

@@ -0,0 +1,168 @@
+# ==============================================================================
+# 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 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 IncrementalLinearRegression
+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
+    )
+    X_train_split = np.array_split(X_train, 2)
+    y_train_split = np.array_split(y_train, 2)
+    model = IncrementalLinearRegression(fit_intercept=True)
+    for i in range(2):
+        model.partial_fit(X_train_split[i], y_train_split[i], queue=queue)
+    model.finalize_fit()
+    y_pred = model.predict(X_test, queue=queue)
+    assert mean_squared_error(y_test, y_pred) < 2396
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.skip(reason="pickling not implemented for oneDAL entities")
+def test_pickle(queue, dtype):
+    # TODO Implement pickling for oneDAL entities
+    X, y = load_diabetes(return_X_y=True)
+    X, y = X.astype(dtype), y.astype(dtype)
+    model = IncrementalLinearRegression(fit_intercept=True)
+    model.partial_fit(X, y, queue=queue)
+    model.finalize_fit()
+    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("num_blocks", [1, 2, 10])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_full_results(queue, num_blocks, dtype):
+    seed = 42
+    num_features, num_targets = 19, 7
+    num_samples_train, num_samples_test = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=num_targets, dtype=dtype)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples_train, num_features), dtype=dtype)
+    y = X @ coef + intercept[np.newaxis, :]
+    X_split = np.array_split(X, num_blocks)
+    y_split = np.array_split(y, num_blocks)
+
+    model = IncrementalLinearRegression(fit_intercept=True)
+    for i in range(num_blocks):
+        model.partial_fit(X_split[i], y_split[i], queue=queue)
+    model.finalize_fit()
+
+    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(intercept, model.intercept_, rtol=tol)
+
+    Xt = gen.random(size=(num_samples_test, num_features), dtype=dtype)
+    gtr = Xt @ coef + intercept[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("num_blocks", [1, 2, 10])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_no_intercept_results(queue, num_blocks, dtype):
+    seed = 42
+    num_features, num_targets = 19, 7
+    num_samples_train, num_samples_test = 3500, 1999
+
+    gen = np.random.default_rng(seed)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples_train, num_features), dtype=dtype)
+    y = X @ coef
+
+    X_split = np.array_split(X, num_blocks)
+    y_split = np.array_split(y, num_blocks)
+
+    model = IncrementalLinearRegression(fit_intercept=False)
+    for i in range(num_blocks):
+        model.partial_fit(X_split[i], y_split[i], queue=queue)
+    model.finalize_fit()
+
+    # TODO Find out is it necessary to have accuracy so different for float32 and float64
+    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=(num_samples_test, num_features), 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
+    num_samples = 3500
+    num_features, num_targets = 14, 9
+
+    gen = np.random.default_rng(seed)
+    intercept = gen.random(size=num_targets, dtype=dtype)
+    coef = gen.random(size=(num_targets, num_features), dtype=dtype).T
+
+    X = gen.random(size=(num_samples, num_features), dtype=dtype)
+    gtr = X @ coef + intercept[np.newaxis, :]
+
+    model = IncrementalLinearRegression(fit_intercept=True)
+    model.coef_ = coef.T
+    model.intercept_ = intercept
+
+    res = model.predict(X, queue=queue)
+
+    tol = 1e-5 if res.dtype == np.float32 else 1e-7
+    assert_allclose(gtr, res, rtol=tol)

onedal/linear_model/tests/test_incremental_ridge_regression.py

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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 IncrementalRidge
+    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
+        )
+        X_train_split = np.array_split(X_train, 2)
+        y_train_split = np.array_split(y_train, 2)
+        model = IncrementalRidge(fit_intercept=True, alpha=0.1)
+        for i in range(2):
+            model.partial_fit(X_train_split[i], y_train_split[i], queue=queue)
+        model.finalize_fit()
+        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])
+    @pytest.mark.skip(reason="pickling not implemented for oneDAL entities")
+    def test_pickle(queue, dtype):
+        # TODO Implement pickling for oneDAL entities
+        X, y = load_diabetes(return_X_y=True)
+        X, y = X.astype(dtype), y.astype(dtype)
+        model = IncrementalRidge(fit_intercept=True, alpha=0.5)
+        model.partial_fit(X, y, queue=queue)
+        model.finalize_fit()
+        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("num_blocks", [1, 2, 10])
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    def test_no_intercept_results(queue, num_blocks, 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)
+        X_split = np.array_split(X, num_blocks)
+        y_split = np.array_split(y, num_blocks)
+        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 = IncrementalRidge(fit_intercept=False, alpha=alpha)
+        for i in range(num_blocks):
+            model.partial_fit(X_split[i], y_split[i], queue=queue)
+        model.finalize_fit()
+
+        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)

onedal/linear_model/tests/test_linear_regression.py

@@ -0,0 +1,149 @@
+# ===============================================================================
+# 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 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)

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)

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)

onedal/neighbors/__init__.py

@@ -0,0 +1,19 @@
+# ===============================================================================
+# 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"]