scikit-learn-intelex 2024.6.0__py312-none-manylinux1_x86_64.whl → 2024.7.0__py312-none-manylinux1_x86_64.whl

sklearnex/tests/_utils_spmd.py

@@ -0,0 +1,185 @@
+# ==============================================================================
+# 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, 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)
+    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.
+    """
+
+    sorted_spmd_result = spmd_result[np.argsort(np.linalg.norm(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(_as_numpy(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.
+    """
+
+    local_batch_labels = _get_local_tensor(batch_labels)
+    assert_allclose(
+        spmd_centers[_as_numpy(spmd_labels)], batch_centers[local_batch_labels], **kwargs
+    )

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)

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:

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,
 )
@@ -139,6 +140,9 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             ]:
                 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 +165,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 +185,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 +202,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(
         [

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,
 )
@@ -73,23 +74,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
 
 
@@ -148,8 +149,13 @@ STABILITY_INSTANCES = _sklearn_clone_dict(
 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]()
 
@@ -173,6 +179,8 @@ def test_special_estimator_stability(estimator, method, dataframe, queue):
         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]
 
@@ -194,6 +202,8 @@ 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):
@@ -215,6 +225,8 @@ def test_sparse_estimator_stability(estimator, method, dataframe, queue):
 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]