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

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -40,11 +40,11 @@ from onedal.common.hyperparameters import get_hyperparameters
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import (
-    ExtensionEstimator,
     PatchingConditionsChain,
     _add_inc_serialization_note,
     register_hyperparameters,
 )
+from ..base import oneDALEstimator
 
 
 @register_hyperparameters(
@@ -57,7 +57,7 @@ from .._utils import (
     decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
 class IncrementalLinearRegression(
-    ExtensionEstimator, MultiOutputMixin, RegressorMixin, BaseEstimator
+    MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator
 ):
     """
     Trains a linear regression model, allows for computation if the data are split into

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_ridge.py

@@ -35,19 +35,14 @@ if sklearn_check_version("1.2"):
 from onedal.linear_model import IncrementalRidge as onedal_IncrementalRidge
 
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import (
-    ExtensionEstimator,
-    PatchingConditionsChain,
-    _add_inc_serialization_note,
-)
+from .._utils import PatchingConditionsChain, _add_inc_serialization_note
+from ..base import oneDALEstimator
 
 
 @control_n_jobs(
     decorated_methods=["fit", "partial_fit", "predict", "score", "_onedal_finalize_fit"]
 )
-class IncrementalRidge(
-    ExtensionEstimator, MultiOutputMixin, RegressorMixin, BaseEstimator
-):
+class IncrementalRidge(MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator):
     """
     Incremental estimator for Ridge Regression.
     Allows to train Ridge Regression if data is splitted into batches.

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/linear.py

@@ -26,12 +26,8 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
 from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import (
-    PatchableEstimator,
-    PatchingConditionsChain,
-    get_patch_message,
-    register_hyperparameters,
-)
+from .._utils import PatchingConditionsChain, get_patch_message, register_hyperparameters
+from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
 if not sklearn_check_version("1.2"):
@@ -47,7 +43,7 @@ from onedal.utils.validation import _num_features, _num_samples
 
 @register_hyperparameters({"fit": get_hyperparameters("linear_regression", "train")})
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-class LinearRegression(PatchableEstimator, _sklearn_LinearRegression):
+class LinearRegression(oneDALEstimator, _sklearn_LinearRegression):
     __doc__ = _sklearn_LinearRegression.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -38,20 +38,12 @@ if daal_check_version((2024, "P", 1)):
 
     from .._config import get_config
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchableEstimator, PatchingConditionsChain, get_patch_message
+    from .._utils import PatchingConditionsChain, get_patch_message
+    from ..base import oneDALEstimator
     from ..utils.validation import validate_data
 
     _sparsity_enabled = daal_check_version((2024, "P", 700))
 
-    class BaseLogisticRegression(ABC):
-        def _onedal_gpu_save_attributes(self):
-            assert hasattr(self, "_onedal_estimator")
-            self.classes_ = self._onedal_estimator.classes_
-            self.coef_ = self._onedal_estimator.coef_
-            self.intercept_ = self._onedal_estimator.intercept_
-            self.n_features_in_ = self._onedal_estimator.n_features_in_
-            self.n_iter_ = self._onedal_estimator.n_iter_
-
     @control_n_jobs(
         decorated_methods=[
             "fit",
@@ -61,9 +53,7 @@ if daal_check_version((2024, "P", 1)):
             "score",
         ]
     )
-    class LogisticRegression(
-        PatchableEstimator, _sklearn_LogisticRegression, BaseLogisticRegression
-    ):
+    class LogisticRegression(oneDALEstimator, _sklearn_LogisticRegression):
         __doc__ = _sklearn_LogisticRegression.__doc__
 
         if sklearn_check_version("1.2"):
@@ -110,6 +100,14 @@ if daal_check_version((2024, "P", 1)):
 
         _onedal_cpu_fit = daal4py_fit
 
+        def _onedal_gpu_save_attributes(self):
+            assert hasattr(self, "_onedal_estimator")
+            self.classes_ = self._onedal_estimator.classes_
+            self.coef_ = self._onedal_estimator.coef_
+            self.intercept_ = self._onedal_estimator.intercept_
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+            self.n_iter_ = self._onedal_estimator.n_iter_
+
         def fit(self, X, y, sample_weight=None):
             if sklearn_check_version("1.2"):
                 self._validate_params()

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/ridge.py

@@ -38,11 +38,12 @@ if daal_check_version((2024, "P", 600)):
     from onedal.utils.validation import _num_features, _num_samples
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchableEstimator, PatchingConditionsChain
+    from .._utils import PatchingConditionsChain
+    from ..base import oneDALEstimator
     from ..utils.validation import validate_data
 
     @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-    class Ridge(PatchableEstimator, _sklearn_Ridge):
+    class Ridge(oneDALEstimator, _sklearn_Ridge):
         __doc__ = _sklearn_Ridge.__doc__
 
         if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/manifold/t_sne.py

@@ -14,12 +14,15 @@
 # limitations under the License.
 # ===============================================================================
 
+from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.manifold import TSNE
 from onedal._device_offload import support_input_format
 
-from .._utils import PatchableEstimator
+from ..base import oneDALEstimator
 
 TSNE.fit = support_input_format(TSNE.fit)
 TSNE.fit_transform = support_input_format(TSNE.fit_transform)
-TSNE._doc_link_module = "daal4py"
-TSNE._doc_link_template = PatchableEstimator._doc_link_template
+
+if sklearn_check_version("1.4"):
+    TSNE._doc_link_module = "daal4py"
+    TSNE._doc_link_url_param_generator = oneDALEstimator._doc_link_url_param_generator

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/neighbors/common.py

@@ -27,12 +27,13 @@ from sklearn.utils.validation import check_is_fitted
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.utils.validation import _check_array, _num_features, _num_samples
 
-from .._utils import PatchableEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
 from ..utils._array_api import get_namespace
 from ..utils.validation import check_feature_names
 
 
-class KNeighborsDispatchingBase(PatchableEstimator):
+class KNeighborsDispatchingBase(oneDALEstimator):
     def _fit_validation(self, X, y=None):
         if sklearn_check_version("1.2"):
             self._validate_params()

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/preview/covariance/covariance.py

@@ -29,17 +29,14 @@ from sklearnex import config_context
 from sklearnex.metrics import pairwise_distances
 
 from ..._device_offload import dispatch, wrap_output_data
-from ..._utils import (
-    PatchableEstimator,
-    PatchingConditionsChain,
-    register_hyperparameters,
-)
+from ..._utils import PatchingConditionsChain, register_hyperparameters
+from ...base import oneDALEstimator
 from ...utils.validation import validate_data
 
 
 @register_hyperparameters({"fit": get_hyperparameters("covariance", "compute")})
 @control_n_jobs(decorated_methods=["fit", "mahalanobis"])
-class EmpiricalCovariance(PatchableEstimator, _sklearn_EmpiricalCovariance):
+class EmpiricalCovariance(oneDALEstimator, _sklearn_EmpiricalCovariance):
     __doc__ = _sklearn_EmpiricalCovariance.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/preview/decomposition/incremental_pca.py

@@ -24,18 +24,15 @@ from onedal.decomposition import IncrementalPCA as onedal_IncrementalPCA
 
 from ..._config import get_config
 from ..._device_offload import dispatch, wrap_output_data
-from ..._utils import (
-    ExtensionEstimator,
-    PatchingConditionsChain,
-    _add_inc_serialization_note,
-)
+from ..._utils import PatchingConditionsChain, _add_inc_serialization_note
+from ...base import oneDALEstimator
 from ...utils.validation import validate_data
 
 
 @control_n_jobs(
     decorated_methods=["fit", "partial_fit", "transform", "_onedal_finalize_fit"]
 )
-class IncrementalPCA(ExtensionEstimator, _sklearn_IncrementalPCA):
+class IncrementalPCA(oneDALEstimator, _sklearn_IncrementalPCA):
 
     _need_to_finalize_attrs = {
         "mean_",

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -15,7 +15,6 @@
 # ==============================================================================
 
 import warnings
-from abc import ABC
 from numbers import Number, Real
 
 import numpy as np
@@ -30,11 +29,12 @@ from daal4py.sklearn.utils.validation import get_requires_y_tag
 from onedal.utils.validation import _check_array, _check_X_y, _column_or_1d
 
 from .._config import config_context, get_config
-from .._utils import PatchableEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
 
-class BaseSVM(PatchableEstimator, BaseEstimator, ABC):
+class BaseSVM(oneDALEstimator):
 
     @property
     def _dual_coef_(self):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/nusvc.py

@@ -40,7 +40,7 @@ from ._common import BaseSVC
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class NuSVC(_sklearn_NuSVC, BaseSVC):
+class NuSVC(BaseSVC, _sklearn_NuSVC):
     __doc__ = _sklearn_NuSVC.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/nusvr.py

@@ -32,7 +32,7 @@ from ._common import BaseSVR
 
 
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-class NuSVR(_sklearn_NuSVR, BaseSVR):
+class NuSVR(BaseSVR, _sklearn_NuSVR):
     __doc__ = _sklearn_NuSVR.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/svc.py

@@ -42,7 +42,7 @@ from ._common import BaseSVC
 @control_n_jobs(
     decorated_methods=["fit", "predict", "_predict_proba", "decision_function", "score"]
 )
-class SVC(_sklearn_SVC, BaseSVC):
+class SVC(BaseSVC, _sklearn_SVC):
     __doc__ = _sklearn_SVC.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/svm/svr.py

@@ -28,7 +28,7 @@ from ._common import BaseSVR
 
 
 @control_n_jobs(decorated_methods=["fit", "predict", "score"])
-class SVR(_sklearn_SVR, BaseSVR):
+class SVR(BaseSVR, _sklearn_SVR):
     __doc__ = _sklearn_SVR.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -26,13 +26,16 @@ from contextlib import redirect_stdout
 from multiprocessing import Pipe, Process, get_context
 
 import pytest
+from sklearn.base import BaseEstimator
 from sklearn.utils import all_estimators
 
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.tests.test_common import _check_primitive_usage_ban
+from sklearnex.base import oneDALEstimator
 from sklearnex.tests.utils import (
     PATCHED_MODELS,
     SPECIAL_INSTANCES,
+    UNPATCHED_MODELS,
     call_method,
     gen_dataset,
     gen_models_info,
@@ -176,6 +179,28 @@ def test_all_estimators_covered(monkeypatch):
     ), f"{uncovered_estimators} are currently not included"
 
 
+def test_oneDALEstimator_inheritance(monkeypatch):
+    """All sklearnex estimators should inherit the oneDALEstimator class, sklearnex-only
+    estimators should have it inherit oneDAL estimator one step before BaseEstimator in the
+    mro.  This is only strictly set for non-preview estimators"""
+    monkeypatch.setattr(pkgutil, "walk_packages", _sklearnex_walk(pkgutil.walk_packages))
+    estimators = all_estimators()  # list of tuples
+    for name, obj in estimators:
+        if "preview" not in obj.__module__ and "daal4py" not in obj.__module__:
+            assert issubclass(
+                obj, oneDALEstimator
+            ), f"{name} does not inherit the oneDALEstimator"
+            # oneDAL estimator should be inherited from before BaseEstimator
+            mro = obj.__mro__
+            assert mro.index(oneDALEstimator) < mro.index(
+                BaseEstimator
+            ), f"incorrect mro in {name}"
+            if not any([issubclass(obj, est) for est in UNPATCHED_MODELS.values()]):
+                assert (
+                    mro[mro.index(oneDALEstimator) + 1] is BaseEstimator
+                ), f"oneDALEstimator should be inherited just before BaseEstimator in {name}"
+
+
 def _fullpath(path):
     return os.path.realpath(os.path.expanduser(path))
 

{scikit_learn_intelex-2025.5.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.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -296,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"))
@@ -325,7 +325,8 @@ def test_table_conversions_memory_leaks(dataframe, queue, order, data_shape, dty
         queue
         and queue.sycl_device.is_gpu
         and (
-            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"])
         )
     ):
         pytest.skip("SYCL device memory leak check requires the level zero sysman")

{scikit_learn_intelex-2025.5.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.5.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.5.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.5.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.5.0
+Requires-Dist: daal ==2025.6.0
 Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22