scikit-learn-intelex 2025.4.0__py311-none-win_amd64.whl → 2025.6.0__py311-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -14,10 +14,14 @@
 # limitations under the License.
 # ==============================================================================
 
+import logging
+
+import pytest
 import sklearn
 
 import onedal
 import sklearnex
+from onedal.tests.utils._device_selection import is_dpctl_device_available
 
 
 def test_get_config_contains_sklearn_params():
@@ -121,3 +125,61 @@ def test_config_context_works():
         "allow_fallback_to_host",
     ]:
         assert onedal_default_config_after_cc[param] == onedal_default_config[param]
+
+
+@pytest.mark.skipif(
+    not is_dpctl_device_available(["gpu"]), reason="Requires a gpu for fallback testing"
+)
+def test_fallback_to_host(caplog):
+    # force a fallback to cpu with direct use of dispatch and PatchingConditionsChain
+    # it should complete with allow_fallback_to_host. The queue should be preserved
+    # and properly used in the second round on gpu
+    from onedal.utils import _sycl_queue_manager as QM
+    from sklearnex._device_offload import dispatch
+    from sklearnex._utils import PatchingConditionsChain
+
+    class _Estimator:
+        def _onedal_gpu_supported(self, method_name, *data):
+            patching_status = PatchingConditionsChain("")
+            patching_status.and_condition(data[0] == "gpu", "")
+            return patching_status
+
+        def _onedal_cpu_supported(self, method_name, *data):
+            patching_status = PatchingConditionsChain("")
+            return patching_status
+
+        def _onedal_test(self, *args, queue=None):
+            if args[0] == "cpu":
+                assert (
+                    queue is None
+                    and QM.__global_queue == QM.__fallback_queue
+                    and QM.get_global_queue() is None
+                )
+            elif args[0] == "gpu":
+                assert queue is not None and QM.get_global_queue() is not None
+
+    start = 0
+    est = _Estimator()
+
+    # set a queue which should persist
+    with (
+        caplog.at_level(logging.DEBUG, logger="sklearnex"),
+        sklearnex.config_context(target_offload="gpu"),
+    ):
+        # True == with cpu (eventually), False == with gpu
+        for fallback in [True, False]:
+            with sklearnex.config_context(allow_fallback_to_host=fallback):
+                dispatch(
+                    est,
+                    "test",
+                    {"onedal": est._onedal_test, "sklearn": None},
+                    "cpu" if fallback else "gpu",
+                )
+
+            # verify that the target_offload has not changed
+            assert sklearnex.get_config()["target_offload"] == "gpu"
+            assert (
+                f": running accelerated version on {'CPU' if fallback else 'GPU'}"
+                in caplog.messages[start:]
+            )
+            start = len(caplog.messages)

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

@@ -18,7 +18,6 @@ import gc
 import logging
 import os
 import tracemalloc
-import types
 import warnings
 from inspect import isclass
 
@@ -29,12 +28,13 @@ from sklearn.base import BaseEstimator, clone
 from sklearn.datasets import make_classification
 from sklearn.model_selection import KFold
 
-from onedal import _is_dpc_backend
+from onedal import _default_backend as backend
 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_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 (
@@ -43,7 +43,6 @@ from sklearnex.tests.utils import (
     SPECIAL_INSTANCES,
     DummyEstimator,
 )
-from sklearnex.utils._array_api import get_namespace
 
 if dpctl_available:
     from dpctl.tensor import usm_ndarray
@@ -51,9 +50,6 @@ if dpctl_available:
 if dpnp_available:
     import dpnp
 
-if _is_dpc_backend:
-    from onedal import _backend
-
 
 CPU_SKIP_LIST = (
     "TSNE",  # too slow for using in testing on common data size
@@ -149,25 +145,22 @@ def gen_clsf_data(n_samples, n_features, dtype=None):
 
 
 def get_traced_memory(queue=None):
-    if _is_dpc_backend and queue and queue.sycl_device.is_gpu:
-        return _backend.get_used_memory(queue)
+    if backend.is_dpc and queue and queue.sycl_device.is_gpu:
+        return backend.get_used_memory(queue)
     else:
         return tracemalloc.get_traced_memory()[0]
 
 
 def take(x, index, axis=0, queue=None):
-    xp, array_api = get_namespace(x)
-    if (
-        dpnp_available
-        and isinstance(x, dpnp.ndarray)
-        or dpctl_available
-        and isinstance(x, usm_ndarray)
-    ):
+    sycl_usm, xp, _ = _get_sycl_namespace(x)
+    if sycl_usm:
         # 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:
+    elif hasattr(x, "__array_namespace__"):
+        # check explicitly instead of sklearn's `get_namespace` as array_api is off by default
+        xp = x.__array_namespace__()
         return xp.take(x, xp.asarray(index, device=x.device), axis=axis)
     else:
         return x.take(index, axis=axis)
@@ -303,7 +296,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_device_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"))
@@ -319,12 +312,8 @@ def test_gpu_memory_leaks(estimator, queue, order, data_shape):
         _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")
+    "dataframe,queue", get_dataframes_and_queues("dpctl,dpnp,array_api", "cpu,gpu")
 )
 @pytest.mark.parametrize("order", ["F", "C"])
 @pytest.mark.parametrize("data_shape", data_shapes)
@@ -332,8 +321,13 @@ def test_gpu_memory_leaks(estimator, queue, order, data_shape):
 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")
+    if (
+        queue
+        and 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")
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_monkeypatch.py

@@ -42,8 +42,8 @@ def test_monkey_patching():
             n = _classes[i][1]
 
             class_module = getattr(p, n).__module__
-            assert class_module.startswith("daal4py") or class_module.startswith(
-                "sklearnex"
+            assert any(
+                class_module.startswith(prefix) for prefix in ["daal4py", "sklearnex"]
             ), "Patching has completed with error."
 
         for i, _ in enumerate(_tokens):
@@ -87,8 +87,8 @@ def test_monkey_patching():
             sklearnex.patch_sklearn(t)
 
             class_module = getattr(p, n).__module__
-            assert class_module.startswith("daal4py") or class_module.startswith(
-                "sklearnex"
+            assert any(
+                class_module.startswith(prefix) for prefix in ["daal4py", "sklearnex"]
             ), "Patching has completed with error."
     finally:
         sklearnex.unpatch_sklearn()

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -16,7 +16,6 @@
 
 
 import importlib
-import inspect
 import logging
 import os
 import re
@@ -33,7 +32,8 @@ from onedal.tests.utils._dataframes_support import (
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
-from sklearnex import is_patched_instance
+from sklearnex import config_context, is_patched_instance
+from sklearnex._utils import get_tags
 from sklearnex.dispatcher import _is_preview_enabled
 from sklearnex.metrics import pairwise_distances, roc_auc_score
 from sklearnex.tests.utils import (
@@ -120,38 +120,11 @@ def test_roc_auc_score_patching(caplog, dataframe, queue, dtype):
     ), f"sklearnex patching issue in roc_auc_score with log: \n{caplog.text}"
 
 
-@pytest.mark.parametrize("dtype", DTYPES)
-@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
-def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
-    with caplog.at_level(logging.WARNING, logger="sklearnex"):
-        est = PATCHED_MODELS[estimator]()
-
-        if queue:
-            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")
-            elif queue.sycl_device.is_gpu and estimator in [
-                "ElasticNet",
-                "Lasso",
-            ]:
-                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 estimator == "IncrementalLinearRegression" and np.issubdtype(
-            dtype, np.integer
-        ):
-            pytest.skip(
-                "IncrementalLinearRegression fails on oneDAL side with int types because dataset is filled by zeroes"
-            )
-        elif method and not hasattr(est, method):
-            pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+def _check_estimator_patching(caplog, dataframe, queue, dtype, est, method):
+    # This should be modified as more array_api frameworks are tested and for
+    # upcoming changes in dpnp and dpctl
 
+    with caplog.at_level(logging.WARNING, logger="sklearnex"):
         X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
         est.fit(X, y)
 
@@ -169,39 +142,95 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
 
 @pytest.mark.parametrize("dtype", DTYPES)
 @pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("estimator, method", gen_models_info(SPECIAL_INSTANCES))
-def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
-    # prepare logging
+@pytest.mark.parametrize("estimator, method", gen_models_info(PATCHED_MODELS))
+def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
+    est = PATCHED_MODELS[estimator]()
 
-    with caplog.at_level(logging.WARNING, logger="sklearnex"):
-        est = SPECIAL_INSTANCES[estimator]
+    if queue:
+        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")
+        elif queue.sycl_device.is_gpu and estimator in [
+            "ElasticNet",
+            "Lasso",
+        ]:
+            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 estimator == "IncrementalLinearRegression" and np.issubdtype(dtype, np.integer):
+        pytest.skip(
+            "IncrementalLinearRegression fails on oneDAL side with int types because dataset is filled by zeroes"
+        )
+    elif method and not hasattr(est, method):
+        pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+    elif dataframe == "array_api" and estimator == "PCA" and "score" in method:
+        pytest.skip(
+            f"PCA.{method} has sklearn array_api support which breaks with array_api_dispatching"
+        )
+    elif (
+        dataframe == "array_api"
+        and not sklearn_check_version("1.3")
+        and estimator == "IncrementalEmpiricalCovariance"
+        and method == "score"
+    ):
+        pytest.skip(
+            f"array checking in sklearn <1.3 does not fully support array_api inputs, causes sklearnex-only estimator failure"
+        )
 
-        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 dataframe == "array_api":
+        # as array_api dispatching is experimental, sklearn support isn't guaranteed.
+        # the infrastructure from sklearn that sklearnex depends on is also susceptible
+        # to failure. In this case compare to sklearn for the same failure. By design
+        # the patching of sklearn should act similarly. Technically this is conformance.
+        with config_context(array_api_dispatch=True):
+            try:
+                _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
+            except Exception as e:
+                # if we are borrowing from sklearn and it fails, then this is something
+                # failing on sklearn-side. It is only allowed to fail if the underlying sklearn
+                # function doesn't support array_api with the set parameters and array_api
+                # support isn't promised by oneDAL
+                tags = get_tags(est)
+                array_api_check = (
+                    hasattr(tags, "array_api_support")
+                    and tags.array_api_support
+                    or hasattr(tags, "onedal_array_api")
+                    and tags.onedal_array_api
+                )
+                if (
+                    array_api_check
+                    or estimator not in UNPATCHED_MODELS
+                    or getattr(PATCHED_MODELS[estimator], method)
+                    != getattr(UNPATCHED_MODELS[estimator], method, None)
+                ):
+                    raise e
 
-        if "NearestNeighbors" in estimator and "radius" in method:
-            pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+    else:
+        _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
 
-        X, y = gen_dataset(est, queue=queue, target_df=dataframe, dtype=dtype)[0]
-        est.fit(X, y)
 
-        if method and not hasattr(est, method):
-            pytest.skip(f"sklearn available_if prevents testing {estimator}.{method}")
+@pytest.mark.parametrize("dtype", DTYPES)
+@pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("estimator, method", gen_models_info(SPECIAL_INSTANCES))
+def test_special_estimator_patching(caplog, dataframe, queue, dtype, estimator, method):
+    est = SPECIAL_INSTANCES[estimator]
 
-        if method:
-            call_method(est, method, X, y)
+    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")
 
-    assert all(
-        [
-            "running accelerated version" in i.message
-            or "fallback to original Scikit-learn" in i.message
-            for i in caplog.records
-        ]
-    ), f"sklearnex patching issue in {estimator}.{method} with log: \n{caplog.text}"
+    if "NearestNeighbors" in estimator and "radius" in method:
+        pytest.skip(f"RadiusNeighbors estimator not implemented in sklearnex")
+
+    _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)
 
 
 @pytest.mark.parametrize("estimator", UNPATCHED_MODELS.keys())
@@ -373,5 +402,5 @@ def test_docstring_patching_match(estimator):
 )
 def test_onedal_supported_member(name, member):
     patched = PATCHED_MODELS[name]
-    sig = str(inspect.signature(getattr(patched, member)))
+    sig = str(signature(getattr(patched, member)))
     assert "(self, method_name, *data)" == sig

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_run_to_run_stability.py

@@ -81,6 +81,13 @@ def eval_method(X, y, est, method):
 
     if not isinstance(res, Iterable):
         results = [_as_numpy(res)] if res is not est else []
+    elif hasattr(res, "dtype") and res.dtype not in [np.object_, np.flexible]:
+        # array_api inputs do not have an __iter__ and this also allows for
+        # multidimensional array-like inputs to be analyzed without slicing.
+        # The check for object and flexible types is because of the
+        # radius_neighbors method in kNeighors algorithms which can return
+        # numpy object arrays of numpy numeric arrays
+        results = [_as_numpy(res).flatten()]
     else:
         results = [_as_numpy(i) for i in res]
 

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

@@ -415,8 +415,8 @@ class DummyEstimator(BaseEstimator):
                 xp=xp,
             )
         else:
-            self.x_attr = from_table(X_table)
-            self.y_attr = from_table(y_table)
+            self.x_attr_ = from_table(X_table)
+            self.y_attr_ = from_table(y_table)
 
         return self
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/utils/validation.py

@@ -21,6 +21,12 @@ from sklearn.utils.validation import _assert_all_finite as _sklearn_assert_all_f
 from sklearn.utils.validation import _num_samples, check_array, check_non_negative
 
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from daal4py.sklearn.utils.validation import (
+    add_dispatcher_docstring,
+    check_feature_names,
+    check_n_features,
+)
+from onedal.utils.validation import is_contiguous
 
 from ._array_api import get_namespace
 
@@ -28,7 +34,6 @@ if sklearn_check_version("1.6"):
     from sklearn.utils.validation import validate_data as _sklearn_validate_data
 
     _finite_keyword = "ensure_all_finite"
-
 else:
     from sklearn.base import BaseEstimator
 
@@ -48,11 +53,7 @@ if daal_check_version((2024, "P", 700)):
         # used for array_api inputs but will allow dpnp ndarrays and dpctl tensors.
         # only check contiguous arrays to prevent unnecessary copying of data, even if
         # non-contiguous arrays can now be converted to oneDAL tables.
-        return (
-            X.dtype in [xp.float32, xp.float64]
-            and hasattr(X, "flags")
-            and (X.flags["C_CONTIGUOUS"] or X.flags["F_CONTIGUOUS"])
-        )
+        return X.dtype in [xp.float32, xp.float64] and is_contiguous(X)
 
 else:
     from daal4py.utils.validation import _assert_all_finite as _onedal_assert_all_finite
@@ -95,6 +96,7 @@ def assert_all_finite(
     )
 
 
+@add_dispatcher_docstring(_sklearn_validate_data)
 def validate_data(
     _estimator,
     /,
@@ -133,22 +135,6 @@ def validate_data(
         if check_y:
             assert_all_finite(next(arg), allow_nan=allow_nan, input_name="y")
 
-    if check_y and "dtype" in kwargs:
-        # validate_data does not do full dtype conversions, as it uses check_X_y
-        # oneDAL can make tables from [int32, float32, float64], requiring
-        # a dtype check and conversion. This will query the array_namespace and
-        # convert y as necessary. This is important especially for regressors.
-        dtype = kwargs["dtype"]
-        if not isinstance(dtype, (tuple, list)):
-            dtype = tuple(dtype)
-
-        outx, outy = out if check_x else (None, out)
-        if outy.dtype not in dtype:
-            yp, _ = get_namespace(outy)
-            # use asarray rather than astype because of numpy support
-            outy = yp.asarray(outy, dtype=dtype[0])
-            out = (outx, outy) if check_x else outy
-
     return out
 
 

{scikit_learn_intelex-2025.4.0.dist-info → scikit_learn_intelex-2025.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-learn-intelex
-Version: 2025.4.0
+Version: 2025.6.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
@@ -17,7 +17,6 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Other Audience
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.9
@@ -31,7 +30,7 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: daal ==2025.4.0
+Requires-Dist: daal ==2025.6.0
 Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22