scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.8.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.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.7.0.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.7.0.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.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/test_config.py

@@ -15,6 +15,8 @@
 # ==============================================================================
 
 import logging
+from contextlib import nullcontext
+from unittest.mock import patch
 
 import numpy as np
 import pytest
@@ -160,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("")
@@ -172,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
 
@@ -194,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",
                 )
 
@@ -205,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.7.0.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.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/tests/utils/base.py

@@ -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.7.0.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)

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/sklearnex/utils/parallel.py

@@ -0,0 +1,97 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import warnings
+from functools import update_wrapper
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+from .._config import config_context, get_config
+
+# Replacement of _FuncWrapper is required to correctly propagate
+# the scikit-learn-intelex configuration functions to the joblib workers.
+if sklearn_check_version("1.7"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config_and_warning_filters(self, config, warning_filters):
+            self.config = config
+            self.warning_filters = warning_filters
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", {})
+            warning_filters = getattr(self, "warning_filters", [])
+            if not config or not warning_filters:
+                warnings.warn(
+                    (
+                        "`sklearn.utils.parallel.delayed` should be used with"
+                        " `sklearn.utils.parallel.Parallel` to make it possible to"
+                        " propagate the scikit-learn configuration of the current thread to"
+                        " the joblib workers."
+                    ),
+                    UserWarning,
+                )
+
+            with config_context(**config), warnings.catch_warnings():
+                warnings.filters = warning_filters
+                return self.function(*args, **kwargs)
+
+elif sklearn_check_version("1.2.1"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config(self, config):
+            self.config = config
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", None)
+            if config is None:
+                warnings.warn(
+                    "`sklearn.utils.parallel.delayed` should be used with "
+                    "`sklearn.utils.parallel.Parallel` to make it possible to propagate "
+                    "the scikit-learn configuration of the current thread to the "
+                    "joblib workers.",
+                    UserWarning,
+                )
+                config = {}
+            with config_context(**config):
+                return self.function(*args, **kwargs)
+
+else:
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            self.config = get_config()
+            update_wrapper(self, self.function)
+
+        def __call__(self, *args, **kwargs):
+            with config_context(**self.config):
+                return self.function(*args, **kwargs)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/utils/validation.py

@@ -16,6 +16,7 @@
 
 import math
 import numbers
+from collections.abc import Sequence
 
 import scipy.sparse as sp
 from sklearn.utils.validation import _assert_all_finite as _sklearn_assert_all_finite
@@ -124,7 +125,6 @@ def validate_data(
         # run local finite check
         allow_nan = ensure_all_finite == "allow-nan"
         # the return object from validate_data can be a single
-
         # element (either x or y) or both (as a tuple). An iterator along with
         # check_x and check_y can go through the output properly without
         # stacking layers of if statements to make sure the proper input_name
@@ -135,6 +135,24 @@ def validate_data(
         if check_y:
             assert_all_finite(next(arg), allow_nan=allow_nan, input_name="y")
 
+    if check_y and kwargs.get("y_numeric", False):
+        # 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.
+        outx, outy = out if check_x else (None, out)
+        yp, _ = get_namespace(outy)
+
+        # avoid using ``kwargs.get("dtype")`` as it will always set up the default
+        dtype = kwargs.get("dtype", (yp.float64, yp.float32, yp.int32))
+        if not isinstance(dtype, Sequence):
+            dtype = tuple(dtype)
+
+        if outy.dtype not in dtype:
+            # 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.7.0.dist-info → scikit_learn_intelex-2025.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-learn-intelex
-Version: 2025.7.0
+Version: 2025.8.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
@@ -30,7 +30,7 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: daal ==2025.7.0
+Requires-Dist: daal ==2025.8.0
 Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22