scikit-learn-intelex 2025.1.0__py312-none-win_amd64.whl → 2025.4.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -15,12 +15,15 @@
 # ==============================================================================
 
 import importlib.util
+import io
 import os
 import pathlib
 import pkgutil
 import re
 import sys
 import trace
+from contextlib import redirect_stdout
+from multiprocessing import Pipe, Process, get_context
 
 import pytest
 from sklearn.utils import all_estimators
@@ -225,23 +228,137 @@ def _whitelist_to_blacklist():
 _TRACE_BLOCK_LIST = _whitelist_to_blacklist()
 
 
+def sklearnex_trace(estimator_name, method_name):
+    """Generate a trace of all function calls in calling estimator.method.
+
+    Parameters
+    ----------
+    estimator_name : str
+        name of estimator which is a key from PATCHED_MODELS or SPECIAL_INSTANCES
+
+    method_name : str
+        name of estimator method which is to be traced and stored
+
+    Returns
+    -------
+    text: str
+        Returns a string output (captured stdout of a python Trace call). It is a
+        modified version to be more informative, completed by a monkeypatching
+        of trace._modname.
+    """
+    # get estimator
+    est = (
+        PATCHED_MODELS[estimator_name]()
+        if estimator_name in PATCHED_MODELS
+        else SPECIAL_INSTANCES[estimator_name]
+    )
+
+    # get dataset
+    X, y = gen_dataset(est)[0]
+    # fit dataset if method does not contain 'fit'
+    if "fit" not in method_name:
+        est.fit(X, y)
+
+    # monkeypatch new modname for clearer info
+    orig_modname = trace._modname
+    try:
+        # initialize tracer to have a more verbose module naming
+        # this impacts ignoremods, but it is not used.
+        trace._modname = _fullpath
+        tracer = trace.Trace(
+            count=0,
+            trace=1,
+            ignoredirs=_TRACE_BLOCK_LIST,
+        )
+        # call trace on method with dataset
+        f = io.StringIO()
+        with redirect_stdout(f):
+            tracer.runfunc(call_method, est, method_name, X, y)
+        return f.getvalue()
+    finally:
+        trace._modname = orig_modname
+
+
+def _trace_daemon(pipe):
+    """function interface for the other process. Information
+    exchanged using a multiprocess.Pipe"""
+    # a sent value with inherent conversion to False will break
+    # the while loop and complete the function
+    while key := pipe.recv():
+        try:
+            text = sklearnex_trace(*key)
+        except:
+            # catch all exceptions and pass back,
+            # this way the process still runs
+            text = ""
+        finally:
+            pipe.send(text)
+
+
+class _FakePipe:
+    """Minimalistic representation of a multiprocessing.Pipe for test development.
+    This allows for running sklearnex_trace in the parent process"""
+
+    _text = ""
+
+    def send(self, key):
+        self._text = sklearnex_trace(*key)
+
+    def recv(self):
+        return self._text
+
+
+@pytest.fixture(scope="module")
+def isolated_trace():
+    """Generates a separate python process for isolated sklearnex traces.
+
+    It is a module scope fixture due to the overhead of importing all the
+    various dependencies and is done once before all the various tests.
+    Each test will first check a cached value, if not existent it will have
+    the waiting child process generate the trace and return the text for
+    caching on its behalf. The isolated process is stopped at test teardown.
+
+    Yields
+    -------
+    pipe_parent: multiprocessing.Connection
+        one end of a duplex pipe to be used by other pytest fixtures for
+        communicating with the special isolated tracing python instance
+        for sklearnex estimators.
+    """
+    # yield _FakePipe()
+    try:
+        # force use of 'spawn' to guarantee a clean python environment
+        # from possible coverage arc tracing
+        ctx = get_context("spawn")
+        pipe_parent, pipe_child = ctx.Pipe()
+        p = ctx.Process(target=_trace_daemon, args=(pipe_child,), daemon=True)
+        p.start()
+        yield pipe_parent
+    finally:
+        # guarantee closing of the process via a try-catch-finally
+        # passing False terminates _trace_daemon's loop
+        pipe_parent.send(False)
+        pipe_parent.close()
+        pipe_child.close()
+        p.join()
+        p.close()
+
+
 @pytest.fixture
-def estimator_trace(estimator, method, cache, capsys, monkeypatch):
-    """Generate a trace of all function calls in calling estimator.method with cache.
+def estimator_trace(estimator, method, cache, isolated_trace):
+    """Create cache of all function calls in calling estimator.method.
 
     Parameters
     ----------
     estimator : str
-        name of estimator which is a key from PATCHED_MODELS or
+        name of estimator which is a key from PATCHED_MODELS or SPECIAL_INSTANCES
 
     method : str
         name of estimator method which is to be traced and stored
 
     cache: pytest.fixture (standard)
 
-    capsys: pytest.fixture (standard)
-
-    monkeypatch: pytest.fixture (standard)
+    isolated_trace: pytest.fixture (test_common.py)
 
     Returns
     -------
@@ -256,31 +373,15 @@ def estimator_trace(estimator, method, cache, capsys, monkeypatch):
     key = "-".join((str(estimator), method))
     flag = cache.get("key", "") != key
     if flag:
-        # get estimator
-        try:
-            est = PATCHED_MODELS[estimator]()
-        except KeyError:
-            est = SPECIAL_INSTANCES[estimator]
-
-        # get dataset
-        X, y = gen_dataset(est)[0]
-        # fit dataset if method does not contain 'fit'
-        if "fit" not in method:
-            est.fit(X, y)
 
-        # initialize tracer to have a more verbose module naming
-        # this impacts ignoremods, but it is not used.
-        monkeypatch.setattr(trace, "_modname", _fullpath)
-        tracer = trace.Trace(
-            count=0,
-            trace=1,
-            ignoredirs=_TRACE_BLOCK_LIST,
-        )
-        # call trace on method with dataset
-        tracer.runfunc(call_method, est, method, X, y)
+        isolated_trace.send((estimator, method))
+        text = isolated_trace.recv()
+        # if tracing does not function in isolated_trace, run it in parent process and error
+        if text == "":
+            sklearnex_trace(estimator, method)
+            # guarantee failure if intermittent
+            assert text, f"sklearnex_trace failure for {estimator}.{method}"
 
-        # collect trace for analysis
-        text = capsys.readouterr().out
         for modulename, file in _TRACE_ALLOW_DICT.items():
             text = text.replace(file, modulename)
         regex_func = (

scikit_learn_intelex-2025.4.0.data/data/Lib/site-packages/sklearnex/tests/test_hyperparameters.py

@@ -0,0 +1,43 @@
+# ==============================================================================
+# 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 pytest
+
+from sklearnex._utils import register_hyperparameters
+
+
+def test_register_hyperparameters():
+    hyperparameters_map = {"op": "hyperparameters"}
+
+    @register_hyperparameters(hyperparameters_map)
+    class Test:
+        pass
+
+    # assert the correct value is returned
+    assert Test.get_hyperparameters("op") == "hyperparameters"
+
+
+def test_register_hyperparameters_issues_warning():
+    hyperparameters_map = {"op": "hyperparameters"}
+
+    @register_hyperparameters(hyperparameters_map)
+    class Test:
+        pass
+
+    # assert a warning is issued when trying to modify the hyperparameters per instance
+    with pytest.warns(Warning):
+        Test().get_hyperparameters("op")

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -35,10 +35,14 @@ from onedal.tests.utils._dataframes_support import (
     get_dataframes_and_queues,
 )
 from onedal.tests.utils._device_selection import get_queues, is_dpctl_device_available
-from onedal.utils._array_api import _get_sycl_namespace
 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:
@@ -72,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)
@@ -132,41 +135,6 @@ N_SPLITS = 10
 ORDER_DICT = {"F": np.asfortranarray, "C": np.ascontiguousarray}
 
 
-if _is_dpc_backend:
-
-    from sklearn.utils.validation import check_is_fitted
-
-    from onedal.datatypes import from_table, to_table
-
-    class DummyEstimatorWithTableConversions(BaseEstimator):
-
-        def fit(self, X, y=None):
-            sua_iface, xp, _ = _get_sycl_namespace(X)
-            X_table = to_table(X)
-            y_table = to_table(y)
-            # The presence of the fitted attributes (ending with a trailing
-            # underscore) is required for the correct check. The cleanup of
-            # the memory will occur at the estimator instance deletion.
-            self.x_attr_ = from_table(
-                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
-            )
-            self.y_attr_ = from_table(
-                y_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
-            )
-            return self
-
-        def predict(self, X):
-            # Checks if the estimator is fitted by verifying the presence of
-            # fitted attributes (ending with a trailing underscore).
-            check_is_fitted(self)
-            sua_iface, xp, _ = _get_sycl_namespace(X)
-            X_table = to_table(X)
-            returned_X = from_table(
-                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
-            )
-            return returned_X
-
-
 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
@@ -370,7 +338,7 @@ def test_table_conversions_memory_leaks(dataframe, queue, order, data_shape, dty
         pytest.skip("SYCL device memory leak check requires the level zero sysman")
 
     _kfold_function_template(
-        DummyEstimatorWithTableConversions,
+        DummyEstimator,
         dataframe,
         data_shape,
         queue,

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.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.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -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.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability.py

@@ -34,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
@@ -117,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(
         [
@@ -153,8 +160,6 @@ def _skip_neighbors(estimator, method):
         and method
         in ["score", "predict", "kneighbors", "kneighbors_graph", "predict_proba"]
     ):
-        if daal_check_version((2025, "P", 200)):
-            pytest.fail("Re-verify failure of algorithms in oneDAL 2025.2")
         pytest.skip(f"{estimator} shows instability on non-Intel(R) hardware")
 
 

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/utils/__init__.py

@@ -21,10 +21,12 @@ from .base import (
     SPECIAL_INSTANCES,
     UNPATCHED_FUNCTIONS,
     UNPATCHED_MODELS,
+    DummyEstimator,
     _get_processor_info,
     call_method,
     gen_dataset,
     gen_models_info,
+    gen_sparse_dataset,
     sklearn_clone_dict,
 )
 
@@ -38,7 +40,9 @@ __all__ = [
     "call_method",
     "gen_models_info",
     "gen_dataset",
+    "gen_sparse_dataset",
     "sklearn_clone_dict",
+    "DummyEstimator",
 ]
 
 _IS_INTEL = "GenuineIntel" in _get_processor_info()

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/tests/utils/base.py

@@ -32,8 +32,11 @@ from sklearn.base import (
 )
 from sklearn.datasets import load_diabetes, load_iris
 from sklearn.neighbors._base import KNeighborsMixin
+from sklearn.utils.validation import check_is_fitted
 
+from onedal.datatypes import from_table, to_table
 from onedal.tests.utils._dataframes_support import _convert_to_dataframe
+from onedal.utils._array_api import _get_sycl_namespace
 from sklearnex import get_patch_map, patch_sklearn, sklearn_is_patched, unpatch_sklearn
 from sklearnex.basic_statistics import BasicStatistics, IncrementalBasicStatistics
 from sklearnex.linear_model import LogisticRegression
@@ -336,6 +339,27 @@ def gen_dataset(
     return output
 
 
+def gen_sparse_dataset(row_count, column_count, **kwargs):
+    """Generate sparse dataset for pytest testing.
+
+    Parameters
+    ----------
+    row_count : number of rows in dataset
+
+    column_count: number of columns in dataset
+
+    kwargs: keyword arguments for scipy.sparse.random_array or scipy.sparse.random
+
+    Returns
+    -------
+    scipy.sparse random matrix or array depending on scipy version
+    """
+    if hasattr(sp, "random_array"):
+        return sp.random_array((row_count, column_count), **kwargs)
+    else:
+        return sp.random(row_count, column_count, **kwargs)
+
+
 DTYPES = [
     np.int8,
     np.int16,
@@ -369,3 +393,44 @@ def _get_processor_info():
         )
 
     return proc
+
+
+class DummyEstimator(BaseEstimator):
+
+    def fit(self, X, y=None):
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        X_table = to_table(X)
+        y_table = to_table(y)
+        # The presence of the fitted attributes (ending with a trailing
+        # underscore) is required for the correct check. The cleanup of
+        # the memory will occur at the estimator instance deletion.
+        if sua_iface:
+            self.x_attr_ = from_table(
+                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
+            )
+            self.y_attr_ = from_table(
+                y_table,
+                sua_iface=sua_iface,
+                sycl_queue=X.sycl_queue if y is None else y.sycl_queue,
+                xp=xp,
+            )
+        else:
+            self.x_attr = from_table(X_table)
+            self.y_attr = from_table(y_table)
+
+        return self
+
+    def predict(self, X):
+        # Checks if the estimator is fitted by verifying the presence of
+        # fitted attributes (ending with a trailing underscore).
+        check_is_fitted(self)
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        X_table = to_table(X)
+        if sua_iface:
+            returned_X = from_table(
+                X_table, sua_iface=sua_iface, sycl_queue=X.sycl_queue, xp=xp
+            )
+        else:
+            returned_X = from_table(X_table)
+
+        return returned_X

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/utils/validation.py → scikit_learn_intelex-2025.4.0.data/data/Lib/site-packages/sklearnex/utils/__init__.py

@@ -14,4 +14,6 @@
 # limitations under the License.
 # ===============================================================================
 
-from daal4py.sklearn.utils.validation import _assert_all_finite
+from .validation import assert_all_finite
+
+__all__ = ["assert_all_finite"]