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

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_linear_regression.py

@@ -161,21 +161,21 @@ def test_overdetermined_system(queue, dtype, fit_intercept):
     if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
         pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
-    X = gen.standard_normal(size=(10, 20))
-    y = gen.standard_normal(size=X.shape[0])
+    X = gen.standard_normal(size=(10, 20)).astype(dtype)
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
 
     model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
     if not fit_intercept:
         A = X.T @ X
         b = X.T @ y
-        x = model.coef_
+        x = np.squeeze(model.coef_)
     else:
         Xi = np.c_[X, np.ones((X.shape[0], 1))]
         A = Xi.T @ Xi
         b = Xi.T @ y
-        x = np.r_[model.coef_, model.intercept_]
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
     residual = A @ x - b
-    assert np.all(np.abs(residual) < 1e-6)
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -189,22 +189,22 @@ def test_singular_matrix(queue, dtype, fit_intercept):
     if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
         pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
-    X = gen.standard_normal(size=(20, 4))
+    X = gen.standard_normal(size=(20, 4)).astype(dtype)
     X[:, 2] = X[:, 3]
-    y = gen.standard_normal(size=X.shape[0])
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
 
     model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
     if not fit_intercept:
         A = X.T @ X
         b = X.T @ y
-        x = model.coef_
+        x = np.squeeze(model.coef_)
     else:
         Xi = np.c_[X, np.ones((X.shape[0], 1))]
         A = Xi.T @ Xi
         b = Xi.T @ y
-        x = np.r_[model.coef_, model.intercept_]
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
     residual = A @ x - b
-    assert np.all(np.abs(residual) < 1e-6)
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -250,10 +250,3 @@ def test_multioutput_regression(queue, dtype, fit_intercept, problem_type):
     expected_pred = X @ model.coef_.T + model.intercept_.reshape((1, -1))
     tol = 1e-5 if pred.dtype == np.float32 else 1e-7
     assert_allclose(pred, expected_pred, rtol=tol)
-
-    # check that it also works when 'y' is a list of lists
-    Y_lists = Y.tolist()
-    model_lists = LinearRegression(fit_intercept=fit_intercept).fit(X, Y_lists)
-    assert_allclose(model.coef_, model_lists.coef_)
-    if fit_intercept:
-        assert_allclose(model.intercept_, model_lists.intercept_)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/tests/test_common.py

@@ -18,6 +18,8 @@ import importlib
 import os
 from glob import glob
 
+from onedal.tests.utils._dataframes_support import test_frameworks
+
 
 def _check_primitive_usage_ban(primitive_name, package, allowed_locations=None):
     """This test blocks the usage of the primitive in
@@ -55,3 +57,15 @@ def test_sklearn_check_version_ban():
     # remove this file from the list
     output = "\n".join([i for i in output if "test_common.py" not in i])
     assert output == "", f"sklearn versioning is occurring in: \n{output}"
+
+
+def test_frameworks_intentionality():
+    """Only silent skip frameworks which are not installed"""
+    fmwks = test_frameworks.replace("array_api", "array_api_strict").split(",")
+    for module in fmwks:
+        try:
+            importlib.import_module(module)
+        # If a module isn't installed, working as intended.
+        # If an ImportError occurs, then something is wrong.
+        except ModuleNotFoundError:
+            pass

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -20,6 +20,7 @@ from collections.abc import Iterable
 from functools import lru_cache
 
 import numpy as np
+import scipy.sparse as sp
 
 from ..utils._third_party import _is_subclass_fast
 
@@ -44,6 +45,8 @@ def _asarray(data, xp, *args, **kwargs):
             for i in range(len(data)):
                 result_data.append(_asarray(data[i], xp, *args, **kwargs))
             data = tuple(result_data)
+        elif sp.issparse(data):
+            pass
         else:
             for i in range(len(data)):
                 data[i] = _asarray(data[i], xp, *args, **kwargs)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/utils/_sycl_queue_manager.py

@@ -15,9 +15,13 @@
 # ==============================================================================
 
 from contextlib import contextmanager
+from types import SimpleNamespace
+
+from onedal import _default_backend as backend
 
 from .._config import _get_config
-from ._third_party import SyclQueue
+from ..datatypes import get_torch_queue
+from ._third_party import SyclQueue, is_torch_tensor
 
 # This special object signifies that the queue system should be
 # disabled. It will force computation to host. This occurs when the
@@ -26,10 +30,15 @@ from ._third_party import SyclQueue
 __fallback_queue = object()
 # single instance of global queue
 __global_queue = None
+# dictionary of generic SYCL queues with default SYCL contexts for
+# reuse
+__dlpack_queue = {}
+# Special queue for non-CPU, non-SYCL data associated with dlpack
+__non_queue = SimpleNamespace(sycl_device=SimpleNamespace(is_cpu=False))
 
 
 def __create_sycl_queue(target):
-    if isinstance(target, SyclQueue) or target is None:
+    if isinstance(target, SyclQueue) or target is None or target is __non_queue:
         return target
     if isinstance(target, (str, int)):
         return SyclQueue(target)
@@ -48,11 +57,8 @@ def get_global_queue():
         signifies computation on host.
     """
     if (queue := __global_queue) is not None:
-        if SyclQueue:
-            if queue is __fallback_queue:
-                return None
-            elif not isinstance(queue, SyclQueue):
-                raise ValueError("Global queue is not a SyclQueue object.")
+        if queue is __fallback_queue:
+            return None
         return queue
 
     target = _get_config()["target_offload"]
@@ -91,6 +97,32 @@ def fallback_to_host():
     __global_queue = __fallback_queue
 
 
+def _get_dlpack_queue(obj: object) -> SyclQueue:
+    # users should not require direct use of this
+    device_type, device_id = obj.__dlpack_device__()
+    if device_type == backend.kDLCPU:
+        return None
+    elif device_type != backend.kDLOneAPI:
+        # Data exists on a non-SYCL, non-CPU device. This will trigger an error
+        # or a fallback if "fallback_to_host" is set in the config
+        return __non_queue
+
+    if is_torch_tensor(obj):
+        return get_torch_queue(obj)
+    else:
+        # no specialized queue can be extracted. Use or generate a generic. Note,
+        # this will behave in unexpected ways for non-default SYCL contexts or
+        # with SYCL sub-devices due to limitations in the dlpack standard (not
+        # enough info).
+        try:
+            queue = __dlpack_queue[device_id]
+        except KeyError:
+            # use filter string capability to yield a queue
+            queue = SyclQueue(str(device_id))
+            __dlpack_queue[device_id] = queue
+        return queue
+
+
 def from_data(*data):
     """Extract the queue from provided data.
 
@@ -109,27 +141,18 @@ def from_data(*data):
     """
     for item in data:
         # iterate through all data objects, extract the queue, and verify that all data objects are on the same device
-        try:
-            usm_iface = getattr(item, "__sycl_usm_array_interface__", None)
-        except RuntimeError as e:
-            if "SUA interface" in str(e):
-                # ignore SUA interface errors and move on
-                continue
-            else:
-                # unexpected, re-raise
-                raise e
-
-        if usm_iface is None:
-            # no interface found - try next data object
+        if usm_iface := getattr(item, "__sycl_usm_array_interface__", None):
+            data_queue = usm_iface["syclobj"]
+        elif hasattr(item, "__dlpack_device__"):
+            data_queue = _get_dlpack_queue(item)
+        else:
+            data_queue = None
+
+        # no queue, i.e. host data, no more work to do
+        if data_queue is None:
             continue
 
-        # extract the queue
         global_queue = get_global_queue()
-        data_queue = usm_iface["syclobj"]
-        if not data_queue:
-            # no queue, i.e. host data, no more work to do
-            continue
-
         # update the global queue if not set
         if global_queue is None:
             update_global_queue(data_queue)
@@ -139,6 +162,9 @@ def from_data(*data):
         data_dev = data_queue.sycl_device
         global_dev = global_queue.sycl_device
         if (data_dev and global_dev) is not None and data_dev != global_dev:
+            # when all data exists on other devices (e.g. not CPU or SYCL devices)
+            # failure will come in backend selection occurring in
+            # sklearnex._device_offload._get_backend when using __non_queue
             raise ValueError(
                 "Data objects are located on different target devices or not on selected device."
             )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/utils/_third_party.py

@@ -120,6 +120,37 @@ def lazy_import(*module_names: str) -> Callable:
     return decorator
 
 
+def convert_sklearnex_queue(func: Callable) -> Callable:
+    """Convert sklearnex pybind11-defined SyclQueue to a dpctl SyclQueue.
+
+    There are circumstances where the internal sklearnex pybind-11-defined
+    SyclQueue generation is required due to gaps in ``dpctl.SyclQueue``
+    initializer. This will change the return value of the function to a
+    ``dpctl.SyclQueue`` if dpctl is available, otherwise it will not wrap
+    the function whatsoever (the function will return an internal SyclQueue).
+
+    Parameters
+    ----------
+    func : callable
+        Function or method to be wrapped.
+
+    Returns
+    -------
+    wrapped : callable
+        Wrapped or original function depending on ``dpctl_available``.
+    """
+    if dpctl_available:
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return SyclQueue(func(*args, **kwargs)._get_capsule())
+
+        return wrapper
+
+    else:
+        return func
+
+
 @functools.lru_cache(100)
 def _is_subclass_fast(cls: type, modname: str, clsname: str) -> bool:
     # Taken directly from array_api_compat.common._helpers to use for
@@ -154,8 +185,8 @@ def is_dpnp_ndarray(x: object) -> bool:
 def is_dpctl_tensor(x: object) -> bool:
     """Return True if 'x' is a dpctl usm_ndarray.
 
-    This function does not import dpnp if it has not already been imported
-    and is therefore cheap to use.
+    This function does not import dpctl.tensor if it has not already been
+    imported and is therefore cheap to use.
 
     Parameters
     ----------
@@ -168,3 +199,22 @@ def is_dpctl_tensor(x: object) -> bool:
         Flag if subclass of dpctl.tensor.usm_ndarray.
     """
     return _is_subclass_fast(type(x), "dpctl.tensor", "usm_ndarray")
+
+
+def is_torch_tensor(x: object) -> bool:
+    """Return True if 'x' is a PyTorch Tensor.
+
+    This function does not import PyTorch if it has not already been imported
+    and is therefore cheap to use.
+
+    Parameters
+    ----------
+    x : object
+        Any python object.
+
+    Returns
+    -------
+    is_torch : bool
+        Flag if subclass of torch.Tensor.
+    """
+    return _is_subclass_fast(type(x), "torch", "Tensor")

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

@@ -46,6 +46,7 @@ __all__ = [
     "model_selection",
     "neighbors",
     "patch_sklearn",
+    "reset_hyperparameters",
     "set_config",
     "sklearn_is_patched",
     "svm",
@@ -56,7 +57,7 @@ __version__ = "2199.9.9"
 onedal_iface_flag = os.environ.get("OFF_ONEDAL_IFACE", "0")
 if onedal_iface_flag == "0":
     from onedal import _spmd_backend
-    from onedal.common.hyperparameters import get_hyperparameters
+    from onedal.common.hyperparameters import get_hyperparameters, reset_hyperparameters
 
     if _spmd_backend is not None:
         __all__.append("spmd")

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

@@ -49,14 +49,16 @@ def _get_backend(
 
     if gpu_device:
         patching_status = obj._onedal_gpu_supported(method_name, *data)
-        if (
-            not patching_status.get_status()
-            and (config := get_config())["allow_fallback_to_host"]
-        ):
+        if not patching_status.get_status() and get_config()["allow_fallback_to_host"]:
             QM.fallback_to_host()
             return None, patching_status
         return patching_status.get_status(), patching_status
 
+    if get_config()["allow_fallback_to_host"]:
+        # This may trigger if the ``onedal.utils._sycl_queue_manager.__non_queue``
+        # object is the queue (e.g. if non-SYCL device data is encountered)
+        QM.fallback_to_host()
+        return None, None
     raise RuntimeError("Device support is not implemented for the supplied data type.")
 
 
@@ -119,12 +121,9 @@ def dispatch(
     # backend can only be a boolean or None, None signifies an unverified backend
     backend: "bool | None" = None
 
-    # config context needs to be saved, as the sycl_queue_manager interacts with
-    # target_offload, which can regenerate a GPU queue later on. Therefore if a
-    # fallback occurs, then the state of target_offload must be set to default
-    # so that later use of get_global_queue only sends to host. We must modify
-    # the target offload settings, but we must also set the original value at the
-    # end, hence the need of a contextmanager.
+    # The _sycl_queue_manager verifies all arguments are on a single SYCL device or
+    # cpu and will otherwise throw an error. If located on a non-SYCL, non-CPU
+    # device, a special queue is set which will cause a failure in ``_get_backend``
     with QM.manage_global_queue(None, *args):
         if onedal_array_api:
             backend, patching_status = _get_backend(obj, method_name, *args)
@@ -183,8 +182,10 @@ def wrap_output_data(func: Callable) -> Callable:
         result = func(self, *args, **kwargs)
         if not (len(args) == 0 and len(kwargs) == 0):
             data = (*args, *kwargs.values())[0]
-
-            if usm_iface := getattr(data, "__sycl_usm_array_interface__", None):
+            # Remove check for result __sycl_usm_array_interface__ on deprecation of use_raw_inputs
+            if (
+                usm_iface := getattr(data, "__sycl_usm_array_interface__", None)
+            ) and not hasattr(result, "__sycl_usm_array_interface__"):
                 queue = usm_iface["syclobj"]
                 return (
                     copy_to_dpnp(queue, result)

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

@@ -27,6 +27,12 @@ from daal4py.sklearn._utils import (
     PatchingConditionsChain as daal4py_PatchingConditionsChain,
 )
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.common.hyperparameters import (
+    get_hyperparameters as onedal_get_hyperparameters,
+)
+from onedal.common.hyperparameters import (
+    reset_hyperparameters as onedal_reset_hyperparameters,
+)
 
 # Not an ideal solution, but this allows for access to the outputs of older
 # sklearnex tag dictionaries in a way similar to the sklearn >=1.6 tag
@@ -121,12 +127,15 @@ def get_sklearnex_version(rule):
 def register_hyperparameters(hyperparameters_map):
     """Decorator for hyperparameters support in estimator class.
 
-    Adds `get_hyperparameters` method to class.
+    Adds `get_hyperparameters` and `reset_hyperparameters` methods to class.
 
     Parameters
     ----------
-    hyperparameters_map : dict
-       Dictionary containing the operator-hyperparameter mapping.
+    hyperparameters_map : Dict[str, Tuple[str, str]]
+       Dictionary containing the mapping of the operator name in the sklearnex API
+       to the tuple (algorithm name, operation name) that contains the arguments to
+       onedal.common.hyperparameters.get_hyperparameters and
+       onedal.common.hyperparameters.reset_hyperparameters functions.
 
     Returns
     -------
@@ -159,9 +168,27 @@ def register_hyperparameters(hyperparameters_map):
                 return self.get_hyperparameters
 
             def get_hyperparameters(self, op):
-                return hyperparameters_map[op]
+                return onedal_get_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
+
+        class StaticHyperparametersResetter:
+            """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
+
+            def __get__(self, instance, _):
+                if instance is not None:
+                    warnings.warn(
+                        "Hyperparameters are static variables and can not be modified per instance."
+                    )
+                return self.reset_hyperparameters
+
+            def reset_hyperparameters(self, op):
+                return onedal_reset_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
 
         cls.get_hyperparameters = StaticHyperparametersAccessor()
+        cls.reset_hyperparameters = StaticHyperparametersResetter()
         return cls
 
     return decorator

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

@@ -16,26 +16,26 @@
 
 import warnings
 
-import numpy as np
 from scipy.sparse import issparse
 from sklearn.base import BaseEstimator
-from sklearn.utils import check_array
-from sklearn.utils.validation import _check_sample_weight
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.basic_statistics import BasicStatistics as onedal_BasicStatistics
 from onedal.utils.validation import _is_csr
 
+from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import StrOptions
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["fit"])
 class BasicStatistics(oneDALEstimator, BaseEstimator):
     """
@@ -126,30 +126,16 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
 
     def _save_attributes(self):
         assert hasattr(self, "_onedal_estimator")
-
-        if self.result_options == "all":
-            result_options = onedal_BasicStatistics.get_all_result_options()
-        else:
-            result_options = self.result_options
-
-        if isinstance(result_options, str):
-            setattr(
-                self,
-                result_options + "_",
-                getattr(self._onedal_estimator, result_options),
-            )
-        elif isinstance(result_options, list):
-            for option in result_options:
-                setattr(self, option + "_", getattr(self._onedal_estimator, option))
+        for option in self._onedal_estimator.options:
+            option += "_"
+            setattr(self, option, getattr(self._onedal_estimator, option))
 
     def __getattr__(self, attr):
-        if self.result_options == "all":
-            result_options = onedal_BasicStatistics.get_all_result_options()
-        else:
-            result_options = self.result_options
         is_deprecated_attr = (
-            isinstance(result_options, str) and (attr == result_options)
-        ) or (isinstance(result_options, list) and (attr in result_options))
+            attr in self._onedal_estimator.options
+            if "_onedal_estimator" in self.__dict__
+            else False
+        )
         if is_deprecated_attr:
             warnings.warn(
                 "Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0"
@@ -195,19 +181,20 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         return patching_status
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
-        X = validate_data(
-            self,
-            X,
-            dtype=[np.float64, np.float32],
-            ensure_2d=False,
-            accept_sparse="csr",
-        )
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, sample_weight)
+            X = validate_data(
+                self,
+                X,
+                dtype=[xp.float64, xp.float32],
+                ensure_2d=False,
+                accept_sparse="csr",
+            )
 
-        if sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         onedal_params = {
             "result_options": self.result_options,
@@ -239,6 +226,8 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         self : object
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         dispatch(
             self,
             "fit",