scikit-learn-intelex 2025.6.1__py313-none-win_amd64.whl → 2025.8.0__py313-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_incremental_linear_spmd.py

@@ -99,9 +99,11 @@ def test_incremental_linear_regression_fit_spmd_gold(
     inclin.fit(dpt_X, dpt_y)
 
     rtol = 1e-5 if (dtype == np.float32) else 1e-7
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, rtol=rtol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), rtol=rtol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, rtol=rtol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), rtol=rtol
+        )
 
 
 @pytest.mark.skipif(
@@ -184,9 +186,11 @@ def test_incremental_linear_regression_partial_fit_spmd_gold(
     inclin.fit(dpt_X, dpt_y)
 
     rtol = 1e-5 if (dtype == np.float32) else 1e-7
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, rtol=rtol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), rtol=rtol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, rtol=rtol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), rtol=rtol
+        )
 
 
 @pytest.mark.skipif(
@@ -242,9 +246,11 @@ def test_incremental_linear_regression_fit_spmd_random(
     inclin_spmd.fit(local_dpt_X, local_dpt_y)
     inclin.fit(dpt_X, dpt_y)
 
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), atol=tol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), atol=tol
+        )
 
     y_pred_spmd = inclin_spmd.predict(dpt_X_test)
     y_pred = inclin.predict(dpt_X_test)
@@ -325,9 +331,11 @@ def test_incremental_linear_regression_partial_fit_spmd_random(
         inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
         inclin.partial_fit(dpt_X, dpt_y)
 
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), atol=tol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), atol=tol
+        )
 
     y_pred_spmd = inclin_spmd.predict(dpt_X_test)
     y_pred = inclin.predict(dpt_X_test)

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_linear_regression_spmd.py

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -83,8 +84,8 @@ def test_linear_spmd_gold(dataframe, queue):
     spmd_model = LinearRegression_SPMD().fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = LinearRegression_Batch().fit(X_train, y_train)
 
-    assert_allclose(spmd_model.coef_, batch_model.coef_)
-    assert_allclose(spmd_model.intercept_, batch_model.intercept_)
+    assert_allclose(_as_numpy(spmd_model.coef_), _as_numpy(batch_model.coef_))
+    assert_allclose(_as_numpy(spmd_model.intercept_), _as_numpy(batch_model.intercept_))
 
     # ensure predictions of batch algo match spmd
     spmd_result = spmd_model.predict(local_dpt_X_test)
@@ -142,8 +143,15 @@ def test_linear_spmd_synthetic(
     batch_model = LinearRegression_Batch().fit(X_train, y_train)
 
     tol = 1e-3 if dtype == np.float32 else 1e-7
-    assert_allclose(spmd_model.coef_, batch_model.coef_, rtol=tol, atol=tol)
-    assert_allclose(spmd_model.intercept_, batch_model.intercept_, rtol=tol, atol=tol)
+    assert_allclose(
+        _as_numpy(spmd_model.coef_), _as_numpy(batch_model.coef_), rtol=tol, atol=tol
+    )
+    assert_allclose(
+        _as_numpy(spmd_model.intercept_),
+        _as_numpy(batch_model.intercept_),
+        rtol=tol,
+        atol=tol,
+    )
 
     # ensure predictions of batch algo match spmd
     # Configure raw input status for spmd estimator

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/svm/_common.py

@@ -233,7 +233,7 @@ class BaseSVC(BaseSVM):
 
         le = LabelEncoder()
         y_ind = le.fit_transform(y_)
-        if not all(np.in1d(classes, le.classes_)):
+        if not np.isin(classes, le.classes_).all():
             raise ValueError("classes should have valid labels that are in y")
 
         recip_freq = len(y_) / (len(le.classes_) * np.bincount(y_ind).astype(np.float64))

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/svm/tests/test_svm.py

@@ -18,6 +18,11 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+try:
+    from scipy.sparse import csr_array as csr_class
+except ImportError:
+    from scipy.sparse import csr_matrix as csr_class
+
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -91,3 +96,29 @@ def test_sklearnex_import_nusvr(dataframe, queue):
         _as_numpy(svc.dual_coef_), [[-1.0, 0.611111, 1.0, -0.611111]], rtol=1e-3
     )
     assert_allclose(_as_numpy(svc.support_), [1, 2, 3, 5])
+
+
+# https://github.com/uxlfoundation/scikit-learn-intelex/issues/1880
+def test_works_with_unsorted_indices():
+    from sklearnex.svm import SVC
+
+    X = csr_class(
+        (
+            np.array(
+                [0.44943642, 0.6316672, 0.6316672, 0.44943642, 0.6316672, 0.6316672]
+            ),
+            np.array([1, 4, 3, 1, 2, 0], dtype=np.int32),
+            np.array([0, 3, 6], dtype=np.int32),
+        ),
+        shape=(2, 5),
+    )
+    y = np.array([1, 0])
+    X_test_single = np.array([[1, 0, 0, 0, 0]], dtype=np.float64)
+    X_test_multi = np.array([[1, 0, 0, 0, 0], [1, 0, 0, 0, 0]], dtype=np.float64)
+    model = SVC(probability=True).fit(X, y)
+    pred_single = model.predict_proba(X_test_single)
+    pred_multi = model.predict_proba(X_test_multi)[0]
+    np.testing.assert_array_equal(
+        pred_single.reshape(-1),
+        pred_multi.reshape(-1),
+    )

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_common.py

@@ -20,6 +20,7 @@ import os
 import pathlib
 import pkgutil
 import re
+import subprocess
 import sys
 import trace
 from contextlib import redirect_stdout
@@ -31,6 +32,7 @@ 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 onedal.tests.utils._dataframes_support import test_frameworks
 from sklearnex.base import oneDALEstimator
 from sklearnex.tests.utils import (
     PATCHED_MODELS,
@@ -118,7 +120,7 @@ def test_target_offload_ban():
         allowed_locations=TARGET_OFFLOAD_ALLOWED_LOCATIONS,
     )
     output = "\n".join(output)
-    assert output == "", f"target offloading is occuring in: \n{output}"
+    assert output == "", f"target offloading is occurring in: \n{output}"
 
 
 def _sklearnex_walk(func):
@@ -146,7 +148,7 @@ def test_class_trailing_underscore_ban(monkeypatch):
     estimators = all_estimators()  # list of tuples
     for name, obj in estimators:
         if "preview" not in obj.__module__ and "daal4py" not in obj.__module__:
-            # propeties also occur in sklearn, especially in deprecations and are expected
+            # properties also occur in sklearn, especially in deprecations and are expected
             # to error if queried and the estimator is not fitted
             assert all(
                 [
@@ -201,6 +203,43 @@ def test_oneDALEstimator_inheritance(monkeypatch):
                 ), f"oneDALEstimator should be inherited just before BaseEstimator in {name}"
 
 
+def test_frameworks_lazy_import(monkeypatch):
+    """Check that all estimators defined in sklearnex do not actively
+    load data frameworks which are not numpy or pandas.
+    """
+    active = ["numpy", "pandas", "dpctl.tensor"]
+    # handle naming conventions for data frameworks in testing
+    frameworks = test_frameworks.replace("dpctl", "dpctl.tensor")
+    frameworks = frameworks.replace("array_api", "array_api_strict")
+    lazy = ",".join([i for i in frameworks.split(",") if i not in active])
+    if not lazy:
+        pytest.skip("No lazily-imported data frameworks available in testing")
+
+    monkeypatch.setattr(pkgutil, "walk_packages", _sklearnex_walk(pkgutil.walk_packages))
+    estimators = all_estimators()  # list of tuples
+
+    filtered_modules = []
+    for name, obj in estimators:
+        # do not test spmd or preview, as they are exempt
+        if "preview" not in obj.__module__ and "spmd" not in obj.__module__:
+            filtered_modules += [obj.__module__]
+
+    modules = ",".join(filtered_modules)
+
+    # import all modules with estimators and check sys.modules for the lazily-imported data
+    # frameworks. It is done in a subprocess to isolate the impact of testing infrastructure
+    # on sys.modules, which may have actively loaded those frameworks into the test env
+    teststr = (
+        "import sys,{mod};assert all([i not in sys.modules for i in '{l}'.split(',')])"
+    )
+    cmd = [sys.executable, "-c", teststr.format(mod=modules, l=lazy)]
+
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        raise AssertionError(f"a framework in '{lazy}' is being actively loaded") from e
+
+
 def _fullpath(path):
     return os.path.realpath(os.path.expanduser(path))
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -15,7 +15,10 @@
 # ==============================================================================
 
 import logging
+from contextlib import nullcontext
+from unittest.mock import patch
 
+import numpy as np
 import pytest
 import sklearn
 
@@ -127,6 +130,27 @@ def test_config_context_works():
         assert onedal_default_config_after_cc[param] == onedal_default_config[param]
 
 
+@pytest.mark.skipif(
+    onedal._default_backend.is_dpc, reason="requires host default backend"
+)
+@pytest.mark.parametrize("target", ["auto", "cpu", "cpu:0", "gpu", 3])
+def test_host_backend_target_offload(target):
+    from sklearnex.neighbors import NearestNeighbors
+
+    err_msg = (
+        r"device use via \`target_offload\` is only supported with the DPC\+\+ backend"
+    )
+
+    est = NearestNeighbors()
+    if target != "auto":
+        with pytest.raises(ValueError, match=err_msg):
+            with sklearnex.config_context(target_offload=target):
+                est.fit(np.eye(5, 8))
+    else:
+        with sklearnex.config_context(target_offload=target):
+            est.fit(np.eye(5, 8))
+
+
 @pytest.mark.skipif(
     not is_dpctl_device_available(["gpu"]), reason="Requires a gpu for fallback testing"
 )
@@ -138,6 +162,11 @@ def test_fallback_to_host(caplog):
     from sklearnex._device_offload import dispatch
     from sklearnex._utils import PatchingConditionsChain
 
+    # This is done due to the use of name mangling in _sycl_queue_manager which
+    # doesn't operate in classes directly. This impacts sklearnex's ``dispatch``
+    # routine, which expects class methods rather than instance methods.
+    is_fallback = lambda: QM.__global_queue == QM.__fallback_queue
+
     class _Estimator:
         def _onedal_gpu_supported(self, method_name, *data):
             patching_status = PatchingConditionsChain("")
@@ -150,11 +179,7 @@ def test_fallback_to_host(caplog):
 
         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
-                )
+                assert queue is None and is_fallback() and QM.get_global_queue() is None
             elif args[0] == "gpu":
                 assert queue is not None and QM.get_global_queue() is not None
 
@@ -172,7 +197,7 @@ def test_fallback_to_host(caplog):
                 dispatch(
                     est,
                     "test",
-                    {"onedal": est._onedal_test, "sklearn": None},
+                    {"onedal": _Estimator._onedal_test, "sklearn": None},
                     "cpu" if fallback else "gpu",
                 )
 
@@ -183,3 +208,49 @@ def test_fallback_to_host(caplog):
                 in caplog.messages[start:]
             )
             start = len(caplog.messages)
+
+
+def test_other_device_fallback():
+    # force a fallback to cpu with direct use of dispatch and PatchingConditionsChain
+    # it should complete with allow_fallback_to_host. The data should be moved to cpu
+    # by calling ``to_device``.
+    from onedal.utils import _sycl_queue_manager as QM
+    from sklearnex._device_offload import dispatch
+    from sklearnex._utils import PatchingConditionsChain
+
+    class FakeCUDA:
+        def __init__(self, data):
+            self.__data = data
+
+        def to_device(self, *args):
+            return self.__data
+
+        def __dlpack_device__(self):
+            return (2, 0)
+
+    class _CPUEstimator:
+        def _onedal_cpu_supported(self, method_name, *data):
+            patching_status = PatchingConditionsChain("")
+            return patching_status
+
+        def _onedal_test(self, data, queue=None):
+            assert queue is None and QM.get_global_queue() is None
+            assert isinstance(data, np.ndarray)
+
+    est = _CPUEstimator()
+    err_msg = "Device support is not implemented for the supplied data type."
+    data = FakeCUDA(np.eye(5, 8))
+
+    for fallback in [True, False]:
+        ctx = nullcontext() if fallback else pytest.raises(RuntimeError, match=err_msg)
+        _mock = patch.object(FakeCUDA, "to_device", wraps=data.to_device)
+        with sklearnex.config_context(allow_fallback_to_host=fallback), ctx, _mock as spy:
+            dispatch(
+                est,
+                "test",
+                {"onedal": _CPUEstimator._onedal_test, "sklearn": None},
+                data,
+            )
+            if fallback:
+                # verify ``FakeCUDA.to_device`` was used
+                spy.assert_called_once_with("cpu")

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

@@ -0,0 +1,111 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numpy as np
+import pytest
+from sklearn.datasets import make_classification, make_regression
+
+from daal4py.sklearn._utils import daal_check_version
+from sklearnex.decomposition import PCA
+from sklearnex.ensemble import RandomForestClassifier
+from sklearnex.linear_model import IncrementalLinearRegression, LinearRegression
+from sklearnex.preview.covariance import EmpiricalCovariance
+
+# Table of estimators to test hyperparameter reset functionality.
+# Each row contains the following elements:
+#
+# [estimator, estimator_type, operation, hyperparameter_name, non_default_value]
+#
+# estimator:            the estimator class to test. For example, EmpiricalCovariance.
+# estimator_type:       the type of operation to get.
+#                       Possible values: "compute", "regression", "classification".
+# operation:            the argument used in get_hyperparameters() and reset_hyperparameters()
+#                       methods of the estimator.
+# hyperparameter_name:  the name of the hyperparameter to test.
+# non_default_value:    the value to set for the hyperparameter before resetting it.
+#                       This value should be different from the default value of the hyperparameter.
+test_estimators = [
+    [EmpiricalCovariance, "compute", "fit", "cpu_macro_block", 10],
+    [IncrementalLinearRegression, "regression", "fit", "cpu_macro_block", 10],
+    [IncrementalLinearRegression, "regression", "partial_fit", "cpu_macro_block", 10],
+    [LinearRegression, "regression", "fit", "cpu_macro_block", 10],
+]
+
+if daal_check_version((2024, "P", 300)):
+    test_estimators.append(
+        [RandomForestClassifier, "classification", "predict", "block_size", 8]
+    )
+
+if daal_check_version((2025, "P", 700)):
+    test_estimators.append([EmpiricalCovariance, "compute", "fit", "cpu_grain_size", 2])
+    test_estimators.append([PCA, "compute", "fit", "cpu_macro_block", 10])
+
+
+def call_estimator(estimator_object, estimator_type, op, X, y=None):
+    if estimator_type == "compute":
+        return estimator_object.fit(X)
+    elif estimator_type == "regression" or estimator_type == "classification":
+        if y is None:
+            raise ValueError("y must be provided for regression or classification tasks")
+        if op == "partial_fit":
+            result = estimator_object.partial_fit(X, y)
+        else:
+            result = estimator_object.fit(X, y)
+        if op == "predict":
+            return estimator_object.predict(X)
+        else:
+            return result
+    else:
+        raise ValueError(f"Unknown estimator type: {estimator_type}")
+
+
+def test_reset_hyperparameters():
+    for estimator, estimator_type, op, param_name, non_default_value in test_estimators:
+
+        if estimator_type == "compute":
+            X = np.random.rand(100, 5)
+            y = None
+        elif estimator_type == "regression":
+            X, y = make_regression(n_features=5, n_informative=5, random_state=777)
+        elif estimator_type == "classification":
+            X, y = make_classification(n_features=5, random_state=777)
+
+        # Create an instance of the estimator
+        est_object = estimator()
+
+        # Fit the model to the data with the default hyperparameters
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Get the hyperparameters before resetting
+        hparams_before = estimator.get_hyperparameters(op)
+        default_hparam_value = getattr(hparams_before, param_name)
+
+        # Fit the model to the data with non-default hyperparameters
+        setattr(hparams_before, param_name, non_default_value)
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Check if the hyperparameters have been set to non-default values
+        assert getattr(hparams_before, param_name) == non_default_value
+        assert getattr(estimator.get_hyperparameters(op), param_name) == non_default_value
+
+        # Reset the hyperparameters
+        estimator.reset_hyperparameters(op)
+        call_estimator(est_object, estimator_type, op, X, y)
+
+        # Check if the hyperparameters have been reset to default values
+        assert (
+            getattr(estimator.get_hyperparameters(op), param_name) == default_hparam_value
+        )

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_memory_usage.py

@@ -35,7 +35,6 @@ from onedal.tests.utils._dataframes_support import (
 )
 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,
@@ -44,13 +43,6 @@ from sklearnex.tests.utils import (
     DummyEstimator,
 )
 
-if dpctl_available:
-    from dpctl.tensor import usm_ndarray
-
-if dpnp_available:
-    import dpnp
-
-
 CPU_SKIP_LIST = (
     "TSNE",  # too slow for using in testing on common data size
     "config_context",  # does not malloc

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py

@@ -95,7 +95,7 @@ def test_n_jobs_support(estimator, n_jobs, caplog):
             "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
+            # but use sklearnex internally, additional development must be done to those
             # functions to bring them to design compliance.
             continue
         try:

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_patching.py

@@ -168,25 +168,25 @@ def test_standard_estimator_patching(caplog, dataframe, queue, dtype, estimator,
         )
     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 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.
+        if estimator == "PCA" and "score" in method:
+            pytest.skip(
+                f"PCA.{method} has sklearn array_api support which breaks with array_api_dispatching"
+            )
+        elif (
+            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"
+            )
+
         with config_context(array_api_dispatch=True):
             try:
                 _check_estimator_patching(caplog, dataframe, queue, dtype, est, method)

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

@@ -153,7 +153,7 @@ def gen_models_info(algorithms, required_inputs=["X", "y"], fit=False, daal4py=T
     required_inputs : list, tuple of strings or None
         list of required args/kwargs for callable attribute (only non-private,
         non-BaseEstimator attributes).  Only one must be present, None
-        signifies taking all non-private attribues, callable or not.
+        signifies taking all non-private attributes, callable or not.
 
     fit: bool (default False)
         Include "fit" method as an estimator-attribute pair
@@ -398,25 +398,13 @@ def _get_processor_info():
 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)
+        self.x_attr_ = from_table(X_table, like=X)
+        self.y_attr_ = from_table(y_table, like=X if y is None else y)
 
         return self
 
@@ -424,13 +412,7 @@ class DummyEstimator(BaseEstimator):
         # 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)
+        returned_X = from_table(X_table, like=X)
 
         return returned_X

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/utils/_array_api.py

@@ -16,11 +16,19 @@
 
 """Tools to support array_api."""
 
+from collections.abc import Callable
+from typing import Union
+
 import numpy as np
 
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.utils._array_api import _get_sycl_namespace
 
+from ..base import oneDALEstimator
+
+if sklearn_check_version("1.6"):
+    from ..base import Tags
+
 if sklearn_check_version("1.2"):
     from sklearn.utils._array_api import get_namespace as sklearn_get_namespace
 
@@ -80,3 +88,66 @@ def get_namespace(*arrays):
         return sklearn_get_namespace(*arrays)
     else:
         return np, False
+
+
+def _enable_array_api(original_class: type[oneDALEstimator]) -> type[oneDALEstimator]:
+    if sklearn_check_version("1.6"):
+
+        def __sklearn_tags__(self) -> Tags:
+            sktags = super(original_class, self).__sklearn_tags__()
+            sktags.onedal_array_api = True
+            return sktags
+
+        original_class.__sklearn_tags__ = __sklearn_tags__
+
+    elif sklearn_check_version("1.3"):
+
+        def _more_tags(self) -> dict[str, bool]:
+            return {"onedal_array_api": True}
+
+        original_class._more_tags = _more_tags
+
+    return original_class
+
+
+def enable_array_api(
+    class_or_str: Union[type[oneDALEstimator], str],
+) -> Union[type[oneDALEstimator], Callable]:
+    """Enable sklearnex to use dpctl, dpnp or array API inputs in oneDAL offloading.
+
+    This wrapper sets the proper flags/tags for the sklearnex infrastructure
+    to maintain the data framework, as the estimator can use it natively.
+
+    Parameters
+    ----------
+    class_or_str : oneDALEstimator subclass or str
+        Class which should enable data zero-copy support in sklearnex. By
+        default it will enable for sklearn versions >1.3. If the wrapper is
+        decorated with an argument, it must be a string defining the oldest
+        sklearn version where array API support begins.
+
+    Returns
+    -------
+    cls or wrapper : modified oneDALEstimator subclass or wrapper
+        Estimator class or wrapper.
+
+    Examples
+    --------
+    @enable_array_api  # default array API support
+    class PCA():
+        ...
+
+    @enable_array_api("1.5")  # array API support for sklearn > 1.5
+    class Ridge():
+        ...
+    """
+    if isinstance(class_or_str, str):
+        # enable array_api for the estimator for a given sklearn version str
+        if sklearn_check_version(class_or_str):
+            return _enable_array_api
+        else:
+            # do not apply the wrapper as it is not supported
+            return lambda x: x
+    else:
+        # default setting (apply array_api enablement for sklearn >=1.3)
+        return _enable_array_api(class_or_str)