scikit-learn-intelex 2024.7.0__py310-none-win_amd64.whl → 2025.0.1__py310-none-win_amd64.whl

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_incremental_linear_spmd.py

@@ -0,0 +1,329 @@
+# ==============================================================================
+# 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
+
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests._utils_spmd import (
+    _generate_regression_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_linear_regression_fit_spmd_gold(
+    dataframe, queue, fit_intercept, macro_block, dtype
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.linear_model import IncrementalLinearRegression
+    from sklearnex.spmd.linear_model import (
+        IncrementalLinearRegression as IncrementalLinearRegression_SPMD,
+    )
+
+    # Create gold data and process into dpt
+    X = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 2.0],
+            [2.0, 4.0],
+            [3.0, 8.0],
+            [4.0, 16.0],
+            [5.0, 32.0],
+            [6.0, 64.0],
+            [7.0, 128.0],
+            [8.0, 0.0],
+            [9.0, 2.0],
+            [10.0, 4.0],
+            [11.0, 8.0],
+            [12.0, 16.0],
+            [13.0, 32.0],
+            [14.0, 64.0],
+            [15.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X)
+    local_dpt_X = _convert_to_dataframe(local_X, sycl_queue=queue, target_df=dataframe)
+
+    y = np.dot(X, [1, 2]) + 3
+    dpt_y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    local_y = _get_local_tensor(y)
+    local_dpt_y = _convert_to_dataframe(local_y, sycl_queue=queue, target_df=dataframe)
+
+    inclin_spmd = IncrementalLinearRegression_SPMD(fit_intercept=fit_intercept)
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+
+        hparams_spmd = inclin_spmd.get_hyperparameters("fit")
+        hparams_spmd.cpu_macro_block = macro_block
+        hparams_spmd.gpu_macro_block = macro_block
+
+    inclin_spmd.fit(local_dpt_X, local_dpt_y)
+    inclin.fit(dpt_X, dpt_y)
+
+    assert_allclose(inclin.coef_, inclin_spmd.coef_)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, inclin_spmd.intercept_)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_linear_regression_partial_fit_spmd_gold(
+    dataframe, queue, fit_intercept, num_blocks, macro_block, dtype
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.linear_model import IncrementalLinearRegression
+    from sklearnex.spmd.linear_model import (
+        IncrementalLinearRegression as IncrementalLinearRegression_SPMD,
+    )
+
+    # Create gold data and process into dpt
+    X = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 2.0],
+            [2.0, 4.0],
+            [3.0, 8.0],
+            [4.0, 16.0],
+            [5.0, 32.0],
+            [6.0, 64.0],
+            [7.0, 128.0],
+            [8.0, 0.0],
+            [9.0, 2.0],
+            [10.0, 4.0],
+            [11.0, 8.0],
+            [12.0, 16.0],
+            [13.0, 32.0],
+            [14.0, 64.0],
+            [15.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X)
+    split_local_X = np.array_split(local_X, num_blocks)
+
+    y = np.dot(X, [1, 2]) + 3
+    dpt_y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+    local_y = _get_local_tensor(y)
+    split_local_y = np.array_split(local_y, num_blocks)
+
+    inclin_spmd = IncrementalLinearRegression_SPMD(fit_intercept=fit_intercept)
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+
+        hparams_spmd = inclin_spmd.get_hyperparameters("fit")
+        hparams_spmd.cpu_macro_block = macro_block
+        hparams_spmd.gpu_macro_block = macro_block
+
+    for i in range(num_blocks):
+        local_dpt_X = _convert_to_dataframe(
+            split_local_X[i], sycl_queue=queue, target_df=dataframe
+        )
+        local_dpt_y = _convert_to_dataframe(
+            split_local_y[i], sycl_queue=queue, target_df=dataframe
+        )
+        inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
+
+    inclin.fit(dpt_X, dpt_y)
+
+    assert_allclose(inclin.coef_, inclin_spmd.coef_)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, inclin_spmd.intercept_)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("num_samples", [100, 1000])
+@pytest.mark.parametrize("num_features", [5, 10])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_linear_regression_fit_spmd_random(
+    dataframe, queue, fit_intercept, num_samples, num_features, macro_block, dtype
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.linear_model import IncrementalLinearRegression
+    from sklearnex.spmd.linear_model import (
+        IncrementalLinearRegression as IncrementalLinearRegression_SPMD,
+    )
+
+    tol = 2e-4 if dtype == np.float32 else 1e-7
+
+    # Generate random data and process into dpt
+    X_train, X_test, y_train, _ = _generate_regression_data(
+        num_samples, num_features, dtype
+    )
+    dpt_X = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    dpt_X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X_train)
+    local_dpt_X = _convert_to_dataframe(local_X, sycl_queue=queue, target_df=dataframe)
+
+    dpt_y = _convert_to_dataframe(y_train, sycl_queue=queue, target_df=dataframe)
+    local_y = _get_local_tensor(y_train)
+    local_dpt_y = _convert_to_dataframe(local_y, sycl_queue=queue, target_df=dataframe)
+
+    inclin_spmd = IncrementalLinearRegression_SPMD(fit_intercept=fit_intercept)
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+
+        hparams_spmd = inclin_spmd.get_hyperparameters("fit")
+        hparams_spmd.cpu_macro_block = macro_block
+        hparams_spmd.gpu_macro_block = macro_block
+
+    inclin_spmd.fit(local_dpt_X, local_dpt_y)
+    inclin.fit(dpt_X, dpt_y)
+
+    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+
+    y_pred_spmd = inclin_spmd.predict(dpt_X_test)
+    y_pred = inclin.predict(dpt_X_test)
+
+    assert_allclose(_as_numpy(y_pred_spmd), _as_numpy(y_pred), atol=tol)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("fit_intercept", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("num_samples", [100, 1000])
+@pytest.mark.parametrize("num_features", [5, 10])
+@pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_linear_regression_partial_fit_spmd_random(
+    dataframe,
+    queue,
+    fit_intercept,
+    num_blocks,
+    num_samples,
+    num_features,
+    macro_block,
+    dtype,
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.linear_model import IncrementalLinearRegression
+    from sklearnex.spmd.linear_model import (
+        IncrementalLinearRegression as IncrementalLinearRegression_SPMD,
+    )
+
+    tol = 3e-4 if dtype == np.float32 else 1e-7
+
+    # Generate random data and process into dpt
+    X_train, X_test, y_train, _ = _generate_regression_data(
+        num_samples, num_features, dtype, 573
+    )
+    dpt_X = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
+    dpt_X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X_train)
+    X_split = np.array_split(X_train, num_blocks)
+    split_local_X = np.array_split(local_X, num_blocks)
+
+    dpt_y = _convert_to_dataframe(y_train, sycl_queue=queue, target_df=dataframe)
+    y_split = np.array_split(y_train, num_blocks)
+    local_y = _get_local_tensor(y_train)
+    split_local_y = np.array_split(local_y, num_blocks)
+
+    inclin_spmd = IncrementalLinearRegression_SPMD(fit_intercept=fit_intercept)
+    inclin = IncrementalLinearRegression(fit_intercept=fit_intercept)
+
+    if macro_block is not None:
+        hparams = inclin.get_hyperparameters("fit")
+        hparams.cpu_macro_block = macro_block
+        hparams.gpu_macro_block = macro_block
+
+        hparams_spmd = inclin_spmd.get_hyperparameters("fit")
+        hparams_spmd.cpu_macro_block = macro_block
+        hparams_spmd.gpu_macro_block = macro_block
+
+    for i in range(num_blocks):
+        local_dpt_X = _convert_to_dataframe(
+            split_local_X[i], sycl_queue=queue, target_df=dataframe
+        )
+        local_dpt_y = _convert_to_dataframe(
+            split_local_y[i], sycl_queue=queue, target_df=dataframe
+        )
+        dpt_X = _convert_to_dataframe(X_split[i], sycl_queue=queue, target_df=dataframe)
+        dpt_y = _convert_to_dataframe(y_split[i], sycl_queue=queue, target_df=dataframe)
+
+        inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
+        inclin.partial_fit(dpt_X, dpt_y)
+
+    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    if fit_intercept:
+        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+
+    y_pred_spmd = inclin_spmd.predict(dpt_X_test)
+    y_pred = inclin.predict(dpt_X_test)
+
+    assert_allclose(_as_numpy(y_pred_spmd), _as_numpy(y_pred), atol=tol)

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_logistic_regression_spmd.py

@@ -116,7 +116,10 @@ def test_logistic_spmd_gold(dataframe, queue):
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.mpi
 def test_logistic_spmd_synthetic(n_samples, n_features, C, tol, dataframe, queue, dtype):
-    pytest.skip("Sporadic failures on coef_ check. Test disabled while fix in progress")
+    if dtype == np.float64:
+        pytest.skip(
+            "Sporadic failures on coef_ check. Test disabled while fix in progress"
+        )
     # TODO: Resolve numerical issues when n_rows_rank < n_cols
     if n_samples <= n_features:
         pytest.skip("Numerical issues when rank rows < columns")

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -22,9 +22,9 @@ from sklearn.utils.validation import _deprecate_positional_args
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
-from sklearnex.utils import get_namespace
 
 from .._device_offload import dispatch, wrap_output_data
+from ..utils._array_api import get_namespace
 from ._common import BaseSVC
 
 if sklearn_check_version("1.0"):

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -23,10 +23,10 @@ from sklearn.utils.validation import _deprecate_positional_args
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
-from sklearnex.utils import get_namespace
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
+from ..utils._array_api import get_namespace
 from ._common import BaseSVC
 
 if sklearn_check_version("1.0"):

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/tests/_utils_spmd.py

@@ -89,10 +89,16 @@ def _generate_classification_data(
     return X_train, X_test, y_train, y_test
 
 
-def _generate_statistic_data(n_samples, n_features, dtype=np.float64, random_state=42):
+def _generate_statistic_data(
+    n_samples, n_features=None, dtype=np.float64, random_state=42
+):
     # Generates statistical data
     gen = np.random.default_rng(random_state)
-    data = gen.uniform(low=-0.3, high=+0.7, size=(n_samples, n_features)).astype(dtype)
+    data = gen.uniform(
+        low=-0.3,
+        high=+0.7,
+        size=(n_samples, n_features) if n_features is not None else (n_samples,),
+    ).astype(dtype)
     return data
 
 
@@ -146,8 +152,11 @@ def _assert_unordered_allclose(spmd_result, batch_result, localize=False, **kwar
     Raises:
         AssertionError: If results do not match.
     """
+    np_spmd_result = _as_numpy(spmd_result)
 
-    sorted_spmd_result = spmd_result[np.argsort(np.linalg.norm(spmd_result, axis=1))]
+    sorted_spmd_result = np_spmd_result[
+        np.argsort(np.linalg.norm(np_spmd_result, axis=1))
+    ]
     if localize:
         local_batch_result = _get_local_tensor(batch_result)
         sorted_batch_result = local_batch_result[
@@ -158,7 +167,7 @@ def _assert_unordered_allclose(spmd_result, batch_result, localize=False, **kwar
             np.argsort(np.linalg.norm(batch_result, axis=1))
         ]
 
-    assert_allclose(_as_numpy(sorted_spmd_result), sorted_batch_result, **kwargs)
+    assert_allclose(sorted_spmd_result, sorted_batch_result, **kwargs)
 
 
 def _assert_kmeans_labels_allclose(
@@ -179,7 +188,11 @@ def _assert_kmeans_labels_allclose(
         AssertionError: If clusters are not correctly assigned.
     """
 
+    np_spmd_labels = _as_numpy(spmd_labels)
+    np_spmd_centers = _as_numpy(spmd_centers)
     local_batch_labels = _get_local_tensor(batch_labels)
     assert_allclose(
-        spmd_centers[_as_numpy(spmd_labels)], batch_centers[local_batch_labels], **kwargs
+        np_spmd_centers[np_spmd_labels],
+        batch_centers[local_batch_labels],
+        **kwargs,
     )

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -38,7 +38,7 @@ from onedal.tests.utils._dataframes_support import (
 from onedal.tests.utils._device_selection import get_queues, is_dpctl_available
 from sklearnex import config_context
 from sklearnex.tests._utils import PATCHED_FUNCTIONS, PATCHED_MODELS, SPECIAL_INSTANCES
-from sklearnex.utils import get_namespace
+from sklearnex.utils._array_api import get_namespace
 
 if _is_dpc_backend:
     from onedal import _backend
@@ -54,6 +54,7 @@ CPU_SKIP_LIST = (
     "IncrementalEmpiricalCovariance",  # dataframe_f issues
     "IncrementalLinearRegression",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
     "IncrementalPCA",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
+    "IncrementalRidge",  # TODO fix memory leak issue in private CI for data_shape = (1000, 100), data_transform_function = dataframe_f
     "LogisticRegression(solver='newton-cg')",  # memory leak fortran (1000, 100)
 )
 

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -133,7 +133,6 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
                 pytest.skip("Hardware does not support fp64 SYCL testing")
             elif queue.sycl_device.is_gpu and estimator in [
-                "KMeans",
                 "ElasticNet",
                 "Lasso",
                 "Ridge",

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability.py

@@ -40,6 +40,7 @@ from sklearn.datasets import (
 )
 
 import daal4py as d4p
+from daal4py.sklearn._utils import daal_check_version
 from onedal.tests.utils._dataframes_support import _as_numpy, get_dataframes_and_queues
 from sklearnex.cluster import DBSCAN, KMeans
 from sklearnex.decomposition import PCA
@@ -114,16 +115,16 @@ def _run_test(estimator, method, datasets):
                     )
 
 
-SPARSE_INSTANCES = _sklearn_clone_dict(
-    {
-        str(i): i
-        for i in [
-            SVC(),
+_sparse_instances = [SVC()]
+if daal_check_version((2024, "P", 700)):  # Test for > 2024.7.0
+    _sparse_instances.extend(
+        [
             KMeans(),
             KMeans(init="random"),
+            KMeans(init="k-means++"),
         ]
-    }
-)
+    )
+SPARSE_INSTANCES = _sklearn_clone_dict({str(i): i for i in _sparse_instances})
 
 STABILITY_INSTANCES = _sklearn_clone_dict(
     {
@@ -144,7 +145,7 @@ STABILITY_INSTANCES = _sklearn_clone_dict(
 )
 
 
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy"))
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
 @pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
 def test_standard_estimator_stability(estimator, method, dataframe, queue):
     if estimator in ["LogisticRegression", "TSNE"]:
@@ -172,7 +173,7 @@ def test_standard_estimator_stability(estimator, method, dataframe, queue):
 
 
 @pytest.mark.allow_sklearn_fallback
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy"))
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
 @pytest.mark.parametrize("estimator, method", gen_models_info(SPECIAL_INSTANCES))
 def test_special_estimator_stability(estimator, method, dataframe, queue):
     if queue is None and estimator in ["LogisticRegression(solver='newton-cg')"]:
@@ -196,7 +197,7 @@ def test_special_estimator_stability(estimator, method, dataframe, queue):
     _run_test(est, method, datasets)
 
 
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy"))
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
 @pytest.mark.parametrize("estimator, method", gen_models_info(SPARSE_INSTANCES))
 def test_sparse_estimator_stability(estimator, method, dataframe, queue):
     if "KMeans" in estimator and method == "score" and queue == None:
@@ -220,7 +221,7 @@ def test_sparse_estimator_stability(estimator, method, dataframe, queue):
     _run_test(est, method, datasets)
 
 
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy"))
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues("numpy,array_api"))
 @pytest.mark.parametrize("estimator, method", gen_models_info(STABILITY_INSTANCES))
 def test_other_estimator_stability(estimator, method, dataframe, queue):
     if "KMeans" in estimator and method == "score" and queue == None:

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/utils/__init__.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 # ===============================================================================
 
-from ._namespace import get_namespace
 from .validation import _assert_all_finite
 
-__all__ = ["get_namespace", "_assert_all_finite"]
+__all__ = ["_assert_all_finite"]

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/utils/_namespace.py → scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/utils/_array_api.py

@@ -14,18 +14,16 @@
 # limitations under the License.
 # ==============================================================================
 
+"""Tools to support array_api."""
+
 import numpy as np
 
 from daal4py.sklearn._utils import sklearn_check_version
-
-from .._device_offload import dpnp_available
+from onedal.utils._array_api import _get_sycl_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._array_api import get_namespace as sklearn_get_namespace
 
-if dpnp_available:
-    import dpnp
-
 
 def get_namespace(*arrays):
     """Get namespace of arrays.
@@ -74,23 +72,10 @@ def get_namespace(*arrays):
         True of the arrays are containers that implement the Array API spec.
     """
 
-    # sycl support designed to work regardless of array_api_dispatch sklearn global value
-    sycl_type = {type(x): x for x in arrays if hasattr(x, "__sycl_usm_array_interface__")}
-
-    if len(sycl_type) > 1:
-        raise ValueError(f"Multiple SYCL types for array inputs: {sycl_type}")
+    sycl_type, xp, is_array_api_compliant = _get_sycl_namespace(*arrays)
 
     if sycl_type:
-
-        (X,) = sycl_type.values()
-
-        if hasattr(X, "__array_namespace__"):
-            return X.__array_namespace__(), True
-        elif dpnp_available and isinstance(X, dpnp.ndarray):
-            return dpnp, False
-        else:
-            raise ValueError(f"SYCL type not recognized: {sycl_type}")
-
+        return xp, is_array_api_compliant
     elif sklearn_check_version("1.2"):
         return sklearn_get_namespace(*arrays)
     else:

{scikit_learn_intelex-2024.7.0.dist-info → scikit_learn_intelex-2025.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-learn-intelex
-Version: 2024.7.0
+Version: 2025.0.1
 Summary: Intel(R) Extension for Scikit-learn is a seamless way to speed up your Scikit-learn application.
 Home-page: https://github.com/intel/scikit-learn-intelex
 Author: Intel Corporation
@@ -31,7 +31,8 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: daal4py ==2024.7.0
+Requires-Dist: daal ==2025.0.1
+Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22