scikit-learn-intelex 2024.6.0__py310-none-win_amd64.whl → 2025.0.0__py310-none-win_amd64.whl

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/sklearnex/tests/_utils_spmd.py

@@ -0,0 +1,198 @@
+# ==============================================================================
+# 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
+from numpy.testing import assert_allclose
+from sklearn.datasets import make_blobs, make_classification, make_regression
+from sklearn.model_selection import train_test_split
+
+from onedal.tests.utils._dataframes_support import _as_numpy
+
+try:
+    import dpctl
+    from dpctl import SyclQueue
+    from mpi4py import MPI
+
+    mpi_libs_available = True
+    gpu_is_available = dpctl.has_gpu_devices()
+except (ImportError, ModuleNotFoundError):
+    mpi_libs_available = False
+
+_mpi_libs_and_gpu_available = mpi_libs_available and gpu_is_available
+
+
+def _get_local_tensor(full_data):
+    """Splits data across ranks.
+
+    Called on each rank to extract the subset of data assigned to that rank.
+
+    Args:
+        full_data (numpy or dpctl array): The entire set of data
+
+    Returns:
+        local_data (numpy or dpctl array): The subset of data used by the rank
+    """
+
+    # create sycl queue and gather communicator details
+    q = SyclQueue("gpu")
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+    size = comm.Get_size()
+
+    # divide data across ranks and move to dpt tensor
+    data_rows = full_data.shape[0]
+    local_start = rank * data_rows // size
+    local_end = (1 + rank) * data_rows // size
+    local_data = full_data[local_start:local_end]
+
+    return local_data
+
+
+def _generate_regression_data(n_samples, n_features, dtype=np.float64, random_state=42):
+    # Generates regression data and divides between train and test
+    X, y = make_regression(
+        n_samples=n_samples, n_features=n_features, random_state=random_state
+    )
+    X = X.astype(dtype)
+    y = y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=random_state)
+    return X_train, X_test, y_train, y_test
+
+
+def _generate_classification_data(
+    n_samples, n_features, n_classes=2, dtype=np.float64, random_state=42
+):
+    # Generates classification data and divides between train and test
+    X, y = make_classification(
+        n_samples=n_samples,
+        n_features=n_features,
+        n_classes=n_classes,
+        n_informative=int(0.5 * n_classes + 1),
+        random_state=random_state,
+    )
+    X = X.astype(dtype)
+    y = y.astype(dtype)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=random_state)
+    return X_train, X_test, y_train, y_test
+
+
+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) if n_features is not None else (n_samples,),
+    ).astype(dtype)
+    return data
+
+
+def _generate_clustering_data(
+    n_samples, n_features, centers=None, dtype=np.float64, random_state=42
+):
+    # Generates clustering data and divides between train and test
+    X, _ = make_blobs(
+        n_samples=n_samples,
+        centers=centers,
+        n_features=n_features,
+        random_state=random_state,
+    )
+    X = X.astype(dtype)
+    X_train, X_test = train_test_split(X, random_state=random_state)
+    return X_train, X_test
+
+
+def _spmd_assert_allclose(spmd_result, batch_result, **kwargs):
+    """Calls assert_allclose on spmd and batch results.
+
+    Called on each rank to compare the spmd result specific to that rank and
+    subset of batch result that corresponds to that rank.
+
+    Args:
+        spmd_result (numpy or dpctl array): The result for the subset of data on the rank the function is called from, computed by the spmd estimator
+        batch_result (numpy array): The result for all data, computed by the batch estimator
+
+    Raises:
+        AssertionError: If all results are not adequately close.
+    """
+
+    # extract chunk from batch result to match with local spmd result
+    local_batch_result = _get_local_tensor(batch_result)
+
+    assert_allclose(_as_numpy(spmd_result), _as_numpy(local_batch_result), **kwargs)
+
+
+def _assert_unordered_allclose(spmd_result, batch_result, localize=False, **kwargs):
+    """Checks if rows in spmd and batch results are aligned, even if not in the same order.
+
+    Called to verify correct unordered results are present. Useful to check KMeans centers
+    or KNN neighbors, where order does not matter. Sorts inputs to handle unordering. Also
+    capable of handling localization.
+
+    Args:
+        spmd_result (numpy or dpctl array): Result computed by the spmd estimator
+        batch_result (numpy array): Result computed by batch estimator
+        localize (bool): Whether of not spmd result is specific to the rank, in which case batch result needs to be localized
+
+    Raises:
+        AssertionError: If results do not match.
+    """
+    np_spmd_result = _as_numpy(spmd_result)
+
+    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[
+            np.argsort(np.linalg.norm(local_batch_result, axis=1))
+        ]
+    else:
+        sorted_batch_result = batch_result[
+            np.argsort(np.linalg.norm(batch_result, axis=1))
+        ]
+
+    assert_allclose(sorted_spmd_result, sorted_batch_result, **kwargs)
+
+
+def _assert_kmeans_labels_allclose(
+    spmd_labels, batch_labels, spmd_centers, batch_centers, **kwargs
+):
+    """Checks if labels for spmd and batch results are aligned, even cluster indices don't match.
+
+    Called to verify labels are assigned the same way on spmd and batch. Uses raw labels (which
+    may not match) to identify cluster center and ensure results match.
+
+    Args:
+        spmd_labels (numpy or dpctl array): The labels for the subset of data on the rank the function is called from, computed by the spmd estimator
+        batch_labels (numpy array): The labels for all data, computed by the batch estimator
+        spmd_centers (numpy or dpctl array): Centers computed by the spmd estimator
+        batch_centers (numpy array): Centers computed by batch estimator
+
+    Raises:
+        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(
+        np_spmd_centers[np_spmd_labels],
+        batch_centers[local_batch_labels],
+        **kwargs,
+    )

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -16,6 +16,7 @@
 
 import sklearn
 
+import onedal
 import sklearnex
 
 
@@ -33,7 +34,10 @@ def test_set_config_works():
     )
 
     config = sklearnex.get_config()
+    onedal_config = onedal._config._get_config()
     assert config["target_offload"] == "cpu:0"
     assert config["allow_fallback_to_host"]
     assert config["assume_finite"]
+    assert onedal_config["target_offload"] == "cpu:0"
+    assert onedal_config["allow_fallback_to_host"]
     sklearnex.set_config(**default_config)

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.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.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -208,10 +208,11 @@ def test_preview_namespace():
         from sklearn.cluster import DBSCAN
         from sklearn.decomposition import PCA
         from sklearn.ensemble import RandomForestClassifier
-        from sklearn.linear_model import LinearRegression
+        from sklearn.linear_model import LinearRegression, Ridge
         from sklearn.svm import SVC
 
         return (
+            Ridge(),
             LinearRegression(),
             PCA(),
             DBSCAN(),
@@ -226,9 +227,12 @@ def test_preview_namespace():
 
         assert _is_preview_enabled()
 
-        lr, pca, dbscan, svc, rfc = get_estimators()
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
         assert "sklearnex" in rfc.__module__
 
+        if daal_check_version((2024, "P", 600)):
+            assert "sklearnex.preview" in ridge.__module__
+
         if daal_check_version((2023, "P", 100)):
             assert "sklearnex" in lr.__module__
         else:
@@ -242,7 +246,8 @@ def test_preview_namespace():
         sklearnex.unpatch_sklearn()
 
     # no patching behavior
-    lr, pca, dbscan, svc, rfc = get_estimators()
+    ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+    assert "sklearn." in ridge.__module__ and "daal4py" not in ridge.__module__
     assert "sklearn." in lr.__module__ and "daal4py" not in lr.__module__
     assert "sklearn." in pca.__module__ and "daal4py" not in pca.__module__
     assert "sklearn." in dbscan.__module__ and "daal4py" not in dbscan.__module__
@@ -254,7 +259,10 @@ def test_preview_namespace():
         sklearnex.patch_sklearn()
         assert not _is_preview_enabled()
 
-        lr, pca, dbscan, svc, rfc = get_estimators()
+        ridge, lr, pca, dbscan, svc, rfc = get_estimators()
+
+        assert "daal4py" in ridge.__module__
+
         if daal_check_version((2023, "P", 100)):
             assert "sklearnex" in lr.__module__
         else:

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -43,6 +43,7 @@ from sklearnex.tests._utils import (
     SPECIAL_INSTANCES,
     UNPATCHED_FUNCTIONS,
     UNPATCHED_MODELS,
+    call_method,
     gen_dataset,
     gen_models_info,
 )
@@ -132,13 +133,15 @@ 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",
             ]:
                 pytest.skip(f"{estimator} does not support GPU queues")
 
+        if "NearestNeighbors" in estimator and "radius" in method:
+            pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+
         if estimator == "TSNE" and method == "fit_transform":
             pytest.skip("TSNE.fit_transform is too slow for common testing")
         elif (
@@ -161,10 +164,8 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
         est.fit(X, y)
 
         if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+            call_method(est, method, X, y)
+
     assert all(
         [
             "running accelerated version" in i.message
@@ -183,11 +184,15 @@ def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator,
     with caplog.at_level(logging.WARNING, logger="sklearnex"):
         est = SPECIAL_INSTANCES[estimator]
 
-        # Its not possible to get the dpnp/dpctl arrays to be in the proper dtype
-        if dtype == np.float16 and queue and not queue.sycl_device.has_aspect_fp16:
-            pytest.skip("Hardware does not support fp16 SYCL testing")
-        elif dtype == np.float64 and queue and not queue.sycl_device.has_aspect_fp64:
-            pytest.skip("Hardware does not support fp64 SYCL testing")
+        if queue:
+            # Its not possible to get the dpnp/dpctl arrays to be in the proper dtype
+            if dtype == np.float16 and not queue.sycl_device.has_aspect_fp16:
+                pytest.skip("Hardware does not support fp16 SYCL testing")
+            elif dtype == np.float64 and not queue.sycl_device.has_aspect_fp64:
+                pytest.skip("Hardware does not support fp64 SYCL testing")
+
+        if "NearestNeighbors" in estimator and "radius" in method:
+            pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
         X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
         est.fit(X, y)
@@ -196,10 +201,7 @@ def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
 
         if method:
-            if method != "score":
-                getattr(est, method)(X)
-            else:
-                est.score(X, y)
+            call_method(est, method, X, y)
 
     assert all(
         [

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability.py

@@ -25,6 +25,7 @@ from _utils import (
     PATCHED_MODELS,
     SPECIAL_INSTANCES,
     _sklearn_clone_dict,
+    call_method,
     gen_dataset,
     gen_models_info,
 )
@@ -39,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
@@ -73,23 +75,23 @@ def eval_method(X, y, est, method):
     est.fit(X, y)
 
     if method:
-        if method != "score":
-            res = getattr(est, method)(X)
-        else:
-            res = est.score(X, y)
+        res = call_method(est, method, X, y)
 
     if not isinstance(res, Iterable):
-        res = [res]
+        results = [_as_numpy(res)] if res is not est else []
+    else:
+        results = [_as_numpy(i) for i in res]
+
+    attributes = [method] * len(results)
 
     # if estimator follows sklearn design rules, then set attributes should have a
     # trailing underscore
-    attributes = [
+    attributes += [
         i
         for i in dir(est)
         if hasattr(est, i) and not i.startswith("_") and i.endswith("_")
     ]
-    results = [getattr(est, i) for i in attributes] + [_as_numpy(i) for i in res]
-    attributes += [method for i in res]
+    results += [getattr(est, i) for i in attributes if i != method]
     return results, attributes
 
 
@@ -113,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(
     {
@@ -143,13 +145,18 @@ 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"]:
         pytest.skip(f"stability not guaranteed for {estimator}")
-    if estimator in ["KMeans", "PCA"] and method == "score" and queue == None:
+    if estimator in ["KMeans", "PCA"] and "score" in method and queue == None:
         pytest.skip(f"variation observed in {estimator}.score")
+    if estimator in ["IncrementalEmpiricalCovariance"] and method == "mahalanobis":
+        pytest.skip("allowed fallback to sklearn occurs")
+
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
     est = PATCHED_MODELS[estimator]()
 
@@ -166,13 +173,15 @@ 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')"]:
         pytest.skip(f"stability not guaranteed for {estimator}")
     if "KMeans" in estimator and method == "score" and queue == None:
         pytest.skip(f"variation observed in KMeans.score")
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
     est = SPECIAL_INSTANCES[estimator]
 
@@ -188,12 +197,14 @@ 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:
         pytest.skip(f"variation observed in KMeans.score")
 
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
     est = SPARSE_INSTANCES[estimator]
 
     if method and not hasattr(est, method):
@@ -210,11 +221,13 @@ 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:
         pytest.skip(f"variation observed in KMeans.score")
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
 
     est = STABILITY_INSTANCES[estimator]
 

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.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.6.0.data/data/Lib/site-packages/sklearnex/utils/_namespace.py → scikit_learn_intelex-2025.0.0.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.6.0.dist-info → scikit_learn_intelex-2025.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-learn-intelex
-Version: 2024.6.0
+Version: 2025.0.0
 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.6.0
+Requires-Dist: daal ==2025.0.0
+Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22