scikit-learn-intelex 2025.0.1__py312-none-win_amd64.whl → 2025.2.0__py312-none-win_amd64.whl

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

@@ -23,7 +23,6 @@ import warnings
 from inspect import isclass
 
 import numpy as np
-import pandas as pd
 import pytest
 from scipy.stats import pearsonr
 from sklearn.base import BaseEstimator, clone
@@ -35,11 +34,23 @@ from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
-from onedal.tests.utils._device_selection import get_queues, is_dpctl_available
+from onedal.tests.utils._device_selection import get_queues, is_dpctl_device_available
+from onedal.utils._dpep_helpers import dpctl_available, dpnp_available
 from sklearnex import config_context
-from sklearnex.tests._utils import PATCHED_FUNCTIONS, PATCHED_MODELS, SPECIAL_INSTANCES
+from sklearnex.tests.utils import (
+    PATCHED_FUNCTIONS,
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    DummyEstimator,
+)
 from sklearnex.utils._array_api import get_namespace
 
+if dpctl_available:
+    from dpctl.tensor import usm_ndarray
+
+if dpnp_available:
+    import dpnp
+
 if _is_dpc_backend:
     from onedal import _backend
 
@@ -65,7 +76,6 @@ GPU_SKIP_LIST = (
     "config_context",  # does not malloc
     "get_config",  # does not malloc
     "set_config",  # does not malloc
-    "Ridge",  # does not support GPU offloading (fails silently)
     "ElasticNet",  # does not support GPU offloading (fails silently)
     "Lasso",  # does not support GPU offloading (fails silently)
     "SVR",  # does not support GPU offloading (fails silently)
@@ -120,14 +130,17 @@ data_shapes = [
 ]
 
 EXTRA_MEMORY_THRESHOLD = 0.15
+EXTRA_MEMORY_THRESHOLD_PANDAS = 0.25
 N_SPLITS = 10
 ORDER_DICT = {"F": np.asfortranarray, "C": np.ascontiguousarray}
 
 
-def gen_clsf_data(n_samples, n_features):
+def gen_clsf_data(n_samples, n_features, dtype=None):
     data, label = make_classification(
         n_classes=2, n_samples=n_samples, n_features=n_features, random_state=777
     )
+    if dtype:
+        data, label = data.astype(dtype), label.astype(dtype)
     return (
         data,
         label,
@@ -144,8 +157,18 @@ def get_traced_memory(queue=None):
 
 def take(x, index, axis=0, queue=None):
     xp, array_api = get_namespace(x)
-    if array_api:
-        return xp.take(x, xp.asarray(index, device=queue), axis=axis)
+    if (
+        dpnp_available
+        and isinstance(x, dpnp.ndarray)
+        or dpctl_available
+        and isinstance(x, usm_ndarray)
+    ):
+        # Using the same sycl queue for dpnp.ndarray or usm_ndarray.
+        return xp.take(
+            x, xp.asarray(index, usm_type="device", sycl_queue=x.sycl_queue), axis=axis
+        )
+    elif array_api:
+        return xp.take(x, xp.asarray(index, device=x.device), axis=axis)
     else:
         return x.take(index, axis=axis)
 
@@ -184,11 +207,13 @@ def split_train_inference(kf, x, y, estimator, queue=None):
     return mem_tracks
 
 
-def _kfold_function_template(estimator, dataframe, data_shape, queue=None, func=None):
+def _kfold_function_template(
+    estimator, dataframe, data_shape, queue=None, func=None, dtype=None
+):
     tracemalloc.start()
 
     n_samples, n_features = data_shape
-    X, y, data_memory_size = gen_clsf_data(n_samples, n_features)
+    X, y, data_memory_size = gen_clsf_data(n_samples, n_features, dtype=dtype)
     kf = KFold(n_splits=N_SPLITS)
     if func:
         X = func(X)
@@ -226,15 +251,18 @@ def _kfold_function_template(estimator, dataframe, data_shape, queue=None, func=
     else:
         name = estimator.__name__
 
+    threshold = (
+        EXTRA_MEMORY_THRESHOLD_PANDAS if dataframe == "pandas" else EXTRA_MEMORY_THRESHOLD
+    )
     message = (
         "Size of extra allocated memory {} using garbage collector "
-        f"is greater than {EXTRA_MEMORY_THRESHOLD * 100}% of input data"
+        f"is greater than {threshold * 100}% of input data"
         f"\n\tAlgorithm: {name}"
         f"\n\tInput data size: {data_memory_size} bytes"
         "\n\tExtra allocated memory size: {} bytes"
         " / {} %"
     )
-    if mem_diff >= EXTRA_MEMORY_THRESHOLD * data_memory_size:
+    if mem_diff >= threshold * data_memory_size:
         logging.warning(
             message.format(
                 "before", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
@@ -253,7 +281,7 @@ def _kfold_function_template(estimator, dataframe, data_shape, queue=None, func=
     # as it looks like a memory leak (at least there is no way to discern a
     # leak on the first run).
     if queue is None or queue.sycl_device.is_cpu:
-        assert mem_diff < EXTRA_MEMORY_THRESHOLD * data_memory_size, message.format(
+        assert mem_diff < threshold * data_memory_size, message.format(
             "after", mem_diff, round((mem_diff) / data_memory_size * 100, 2)
         )
 
@@ -275,7 +303,7 @@ def test_memory_leaks(estimator, dataframe, queue, order, data_shape):
 
 
 @pytest.mark.skipif(
-    os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_available("gpu"),
+    os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_device_available("gpu"),
     reason="SYCL device memory leak check requires the level zero sysman",
 )
 @pytest.mark.parametrize("queue", get_queues("gpu"))
@@ -289,3 +317,31 @@ def test_gpu_memory_leaks(estimator, queue, order, data_shape):
 
     with config_context(target_offload=queue):
         _kfold_function_template(GPU_ESTIMATORS[estimator], None, data_shape, queue, func)
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend,
+    reason="__sycl_usm_array_interface__ support requires DPC backend.",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp", "cpu,gpu")
+)
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("data_shape", data_shapes)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_table_conversions_memory_leaks(dataframe, queue, order, data_shape, dtype):
+    func = ORDER_DICT[order]
+
+    if queue.sycl_device.is_gpu and (
+        os.getenv("ZES_ENABLE_SYSMAN") is None or not is_dpctl_device_available("gpu")
+    ):
+        pytest.skip("SYCL device memory leak check requires the level zero sysman")
+
+    _kfold_function_template(
+        DummyEstimator,
+        dataframe,
+        data_shape,
+        queue,
+        func,
+        dtype,
+    )

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

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

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py

@@ -0,0 +1,108 @@
+# ==============================================================================
+# 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 inspect
+import logging
+from multiprocessing import cpu_count
+
+import pytest
+from sklearn.datasets import make_classification
+from sklearn.exceptions import NotFittedError
+
+from sklearnex.tests.utils import (
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+)
+
+_X, _Y = make_classification(n_samples=40, n_features=4, random_state=42)
+
+
+def _get_estimator_instance(estimator):
+    if estimator in PATCHED_MODELS:
+        est = PATCHED_MODELS[estimator]()
+    elif estimator in SPECIAL_INSTANCES:
+        est = SPECIAL_INSTANCES[estimator]
+    else:
+        raise KeyError(f"{estimator} not in patch_map or SPECIAL_INSTANCES")
+    return est
+
+
+def _check_n_jobs_entry_in_logs(records, function_name, n_jobs):
+    expected_n_jobs = max(n_jobs, n_jobs % (cpu_count() + 1)) if n_jobs else cpu_count()
+    for rec in records:
+        if f"{function_name}: setting {expected_n_jobs} threads" in rec:
+            return True
+    # False if n_jobs is set and not found in logs
+    return n_jobs is None
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+def test_n_jobs_documentation(estimator):
+    est = _get_estimator_instance(estimator)
+    assert "n_jobs" in est.__doc__
+    assert "n_jobs" in est.__class__.__doc__
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+def test_n_jobs_method_decoration(estimator):
+    est = _get_estimator_instance(estimator)
+    for func_name, func in vars(est).items():
+        # hasattr check necessary due to sklearn's available_if wrapper
+        if hasattr(est, func_name) and callable(func):
+            assert hasattr(func, "__onedal_n_jobs_decorated__") == (
+                func_name in est._n_jobs_supported_onedal_methods
+            ), f"{est}.{func_name} n_jobs decoration does not match {est} n_jobs supported methods"
+
+
+@pytest.mark.parametrize("estimator", {**PATCHED_MODELS, **SPECIAL_INSTANCES}.keys())
+@pytest.mark.parametrize("n_jobs", [None, -1, 1, 2])
+def test_n_jobs_support(estimator, n_jobs, caplog):
+
+    est = _get_estimator_instance(estimator)
+    caplog.set_level(logging.DEBUG, logger="sklearnex")
+
+    # copy params and modify n_jobs, assumes estimator inherits from BaseEstimator
+    # or properly supports get_params and set_params methods as defined by sklearn
+    params = est.get_params()
+    params["n_jobs"] = n_jobs
+    est.set_params(**params)
+
+    # check `n_jobs` log entry for supported methods
+    # `fit` call is required before other methods
+    est.fit(_X, _Y)
+    messages = [msg.message for msg in caplog.records]
+    assert _check_n_jobs_entry_in_logs(messages, "fit", n_jobs)
+
+    for method_name in est._n_jobs_supported_onedal_methods:
+        # do not call fit again, handle sklearn's available_if wrapper
+        if method_name == "fit" or (
+            "NearestNeighbors" in estimator and "radius" in method_name
+        ):
+            # radius_neighbors and radius_neighbors_graph violate sklearn fallback guard
+            # but use sklearnex interally, additional development must be done to those
+            # functions to bring them to design compliance.
+            continue
+        try:
+            call_method(est, method_name, _X, _Y)
+        except (NotFittedError, AttributeError) as e:
+            # handle sklearns available_if wrapper
+            continue
+
+        messages = [msg.message for msg in caplog.records]
+        assert _check_n_jobs_entry_in_logs(messages, method_name, n_jobs)

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

@@ -36,7 +36,7 @@ from onedal.tests.utils._dataframes_support import (
 from sklearnex import is_patched_instance
 from sklearnex.dispatcher import _is_preview_enabled
 from sklearnex.metrics import pairwise_distances, roc_auc_score
-from sklearnex.tests._utils import (
+from sklearnex.tests.utils import (
     DTYPES,
     PATCHED_FUNCTIONS,
     PATCHED_MODELS,
@@ -135,7 +135,6 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
             elif queue.sycl_device.is_gpu and estimator in [
                 "ElasticNet",
                 "Lasso",
-                "Ridge",
             ]:
                 pytest.skip(f"{estimator} does not support GPU queues")
 
@@ -144,13 +143,6 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
 
         if estimator == "TSNE" and method == "fit_transform":
             pytest.skip("TSNE.fit_transform is too slow for common testing")
-        elif (
-            estimator == "Ridge"
-            and method in ["predict", "score"]
-            and sys.platform == "win32"
-            and dtype in [np.uint32, np.uint64]
-        ):
-            pytest.skip("Windows segmentation fault for Ridge.predict for unsigned ints")
         elif estimator == "IncrementalLinearRegression" and np.issubdtype(
             dtype, np.integer
         ):

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

@@ -21,14 +21,6 @@ from numbers import Number
 
 import numpy as np
 import pytest
-from _utils import (
-    PATCHED_MODELS,
-    SPECIAL_INSTANCES,
-    _sklearn_clone_dict,
-    call_method,
-    gen_dataset,
-    gen_models_info,
-)
 from numpy.testing import assert_allclose
 from scipy import sparse
 from sklearn.datasets import (
@@ -42,6 +34,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.basic_statistics import BasicStatistics
 from sklearnex.cluster import DBSCAN, KMeans
 from sklearnex.decomposition import PCA
 from sklearnex.metrics import pairwise_distances, roc_auc_score
@@ -52,6 +45,15 @@ from sklearnex.neighbors import (
     NearestNeighbors,
 )
 from sklearnex.svm import SVC
+from sklearnex.tests.utils import (
+    _IS_INTEL,
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+    sklearn_clone_dict,
+)
 
 # to reproduce errors even in CI
 d4p.daalinit(nthreads=100)
@@ -116,6 +118,12 @@ def _run_test(estimator, method, datasets):
 
 
 _sparse_instances = [SVC()]
+if daal_check_version((2025, "P", 200)):  # Test for >= 2025.2.0
+    _sparse_instances.extend(
+        [
+            BasicStatistics(result_options=["sum", "min"]),
+        ]
+    )
 if daal_check_version((2024, "P", 700)):  # Test for > 2024.7.0
     _sparse_instances.extend(
         [
@@ -124,9 +132,9 @@ if daal_check_version((2024, "P", 700)):  # Test for > 2024.7.0
             KMeans(init="k-means++"),
         ]
     )
-SPARSE_INSTANCES = _sklearn_clone_dict({str(i): i for i in _sparse_instances})
+SPARSE_INSTANCES = sklearn_clone_dict({str(i): i for i in _sparse_instances})
 
-STABILITY_INSTANCES = _sklearn_clone_dict(
+STABILITY_INSTANCES = sklearn_clone_dict(
     {
         str(i): i
         for i in [
@@ -145,6 +153,16 @@ STABILITY_INSTANCES = _sklearn_clone_dict(
 )
 
 
+def _skip_neighbors(estimator, method):
+    if (
+        not _IS_INTEL
+        and ("Neighbors" in estimator or "LocalOutlierFactor" in estimator)
+        and method
+        in ["score", "predict", "kneighbors", "kneighbors_graph", "predict_proba"]
+    ):
+        pytest.skip(f"{estimator} shows instability on non-Intel(R) hardware")
+
+
 @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):
@@ -154,6 +172,7 @@ def test_standard_estimator_stability(estimator, method, dataframe, queue):
         pytest.skip(f"variation observed in {estimator}.score")
     if estimator in ["IncrementalEmpiricalCovariance"] and method == "mahalanobis":
         pytest.skip("allowed fallback to sklearn occurs")
+    _skip_neighbors(estimator, method)
 
     if "NearestNeighbors" in estimator and "radius" in method:
         pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
@@ -180,8 +199,11 @@ 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 estimator == "BasicStatistics()" and queue == None:
+        pytest.skip(f"BasicStatistics not deterministic")
     if "NearestNeighbors" in estimator and "radius" in method:
         pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    _skip_neighbors(estimator, method)
 
     est = SPECIAL_INSTANCES[estimator]
 
@@ -200,11 +222,18 @@ def test_special_estimator_stability(estimator, method, dataframe, queue):
 @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 "KMeans" in estimator and method in "score" and queue == None:
+        pytest.skip(f"variation observed in KMeans.{method}")
+    if (
+        not daal_check_version((2025, "P", 0))
+        and "KMeans()" in estimator
+        and queue == None
+    ):
+        pytest.skip(f"variation observed in KMeans.{method} in 2024.7 oneDAL")
     if "NearestNeighbors" in estimator and "radius" in method:
         pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    _skip_neighbors(estimator, method)
+
     est = SPARSE_INSTANCES[estimator]
 
     if method and not hasattr(est, method):
@@ -228,6 +257,7 @@ def test_other_estimator_stability(estimator, method, dataframe, queue):
         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")
+    _skip_neighbors(estimator, method)
 
     est = STABILITY_INSTANCES[estimator]
 

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/sklearnex/tests/utils/__init__.py

@@ -0,0 +1,48 @@
+# ==============================================================================
+# 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 .base import (
+    DTYPES,
+    PATCHED_FUNCTIONS,
+    PATCHED_MODELS,
+    SPECIAL_INSTANCES,
+    UNPATCHED_FUNCTIONS,
+    UNPATCHED_MODELS,
+    DummyEstimator,
+    _get_processor_info,
+    call_method,
+    gen_dataset,
+    gen_models_info,
+    gen_sparse_dataset,
+    sklearn_clone_dict,
+)
+
+__all__ = [
+    "DTYPES",
+    "PATCHED_FUNCTIONS",
+    "PATCHED_MODELS",
+    "UNPATCHED_FUNCTIONS",
+    "UNPATCHED_MODELS",
+    "SPECIAL_INSTANCES",
+    "call_method",
+    "gen_models_info",
+    "gen_dataset",
+    "gen_sparse_dataset",
+    "sklearn_clone_dict",
+    "DummyEstimator",
+]
+
+_IS_INTEL = "GenuineIntel" in _get_processor_info()