scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/_config.py

@@ -18,10 +18,35 @@
 
 import threading
 
+"""
+Default values for global configuration parameters.
+These values are typically managed through the sklearnex.set_config() interface.
+Here we only define the defaults.
+
+target_offload:
+    The device primarily used to perform computations.
+    If string, expected to be "auto" (the execution context
+    is deduced from input data location), or SYCL* filter selector string.
+    Global default: "auto".
+allow_fallback_to_host:
+    If True, allows to fallback computation to host device
+    in case particular estimator does not support the selected one.
+    Global default: False.
+allow_sklearn_after_onedal:
+    If True, allows to fallback computation to sklearn after onedal
+    backend in case of runtime error on onedal backend computations.
+    Global default: True.
+use_raw_input:
+    If True, uses the raw input data in some SPMD onedal backend computations
+    without any checks on data consistency or validity.
+    Note: This option is not recommended for general use.
+    Global default: False.
+"""
 _default_global_config = {
     "target_offload": "auto",
     "allow_fallback_to_host": False,
     "allow_sklearn_after_onedal": True,
+    "use_raw_input": False,
 }
 
 _threadlocal = threading.local()
@@ -39,8 +64,8 @@ def _get_config(copy=True):
     Parameters
     ----------
     copy : bool, default=True
-        If False, the values ​​of the global config are returned,
-        which can further be overwritten.
+        If False, a mutable view of the configuration is returned. Each thread
+        has a separate copy of the configuration.
     Returns
     -------
     config : dict

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/_device_offload.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
-import logging
+import inspect
 from collections.abc import Iterable
 from functools import wraps
 
@@ -22,21 +22,37 @@ import numpy as np
 from sklearn import get_config
 
 from ._config import _get_config
+from .utils import _sycl_queue_manager as QM
 from .utils._array_api import _asarray, _is_numpy_namespace
 from .utils._dpep_helpers import dpctl_available, dpnp_available
 
 if dpctl_available:
-    from dpctl import SyclQueue
     from dpctl.memory import MemoryUSMDevice, as_usm_memory
     from dpctl.tensor import usm_ndarray
 else:
-    import onedal
+    from onedal import _dpc_backend
+
+    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+
+
+def supports_queue(func):
+    """
+    Decorator that updates the global queue based on provided queue and global configuration.
+    If a `queue` keyword argument is provided in the decorated function, its value will be used globally.
+    If no queue is provided, the global queue will be updated from the provided data.
+    In either case, all data objects are verified to be on the same device (or on host).
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        queue = kwargs.get("queue", None)
+        with QM.manage_global_queue(queue, *args) as queue:
+            kwargs["queue"] = queue
+            result = func(self, *args, **kwargs)
+        return result
+
+    return wrapper
 
-    # setting fallback to `object` will make if isinstance call
-    # in _get_global_queue always true for situations without the
-    # dpc backend when `device_offload` is used. Instead, it will
-    # fail at the policy check phase yielding a RuntimeError
-    SyclQueue = getattr(onedal._backend, "SyclQueue", object)
 
 if dpnp_available:
     import dpnp
@@ -69,7 +85,7 @@ def _copy_to_usm(queue, array):
         return array
 
 
-def _transfer_to_host(queue, *data):
+def _transfer_to_host(*data):
     has_usm_data, has_host_data = False, False
 
     host_data = []
@@ -82,17 +98,10 @@ def _transfer_to_host(queue, *data):
                     "dpctl need to be installed to work "
                     "with __sycl_usm_array_interface__"
                 )
-            if queue is not None:
-                if queue.sycl_device != usm_iface["syclobj"].sycl_device:
-                    raise RuntimeError(
-                        "Input data shall be located " "on single target device"
-                    )
-            else:
-                queue = usm_iface["syclobj"]
 
             buffer = as_usm_memory(item).copy_to_host()
             order = "C"
-            if usm_iface["strides"] is not None:
+            if usm_iface["strides"] is not None and len(usm_iface["strides"]) > 1:
                 if usm_iface["strides"][0] < usm_iface["strides"][1]:
                     order = "F"
             item = np.ndarray(
@@ -117,88 +126,75 @@ def _transfer_to_host(queue, *data):
             raise RuntimeError("Input data shall be located on single target device")
 
         host_data.append(item)
-    return has_usm_data, queue, host_data
-
-
-def _get_global_queue():
-    target = _get_config()["target_offload"]
-
-    if target != "auto":
-        if isinstance(target, SyclQueue):
-            return target
-        return SyclQueue(target)
-    return None
+    return has_usm_data, host_data
 
 
 def _get_host_inputs(*args, **kwargs):
-    q = _get_global_queue()
-    _, q, hostargs = _transfer_to_host(q, *args)
-    _, q, hostvalues = _transfer_to_host(q, *kwargs.values())
+    _, hostargs = _transfer_to_host(*args)
+    _, hostvalues = _transfer_to_host(*kwargs.values())
     hostkwargs = dict(zip(kwargs.keys(), hostvalues))
-    return q, hostargs, hostkwargs
-
+    return hostargs, hostkwargs
 
-def _run_on_device(func, obj=None, *args, **kwargs):
-    if obj is not None:
-        return func(obj, *args, **kwargs)
-    return func(*args, **kwargs)
 
-
-def support_input_format(freefunc=False, queue_param=True):
+def support_input_format(func):
     """
     Converts and moves the output arrays of the decorated function
     to match the input array type and device.
     Puts SYCLQueue from data to decorated function arguments.
+    """
 
-    Parameters
-    ----------
-    freefunc (bool) : Set to True if decorates free function.
-    queue_param (bool) : Set to False if the decorated function has no `queue` parameter
+    def invoke_func(self_or_None, *args, **kwargs):
+        if self_or_None is None:
+            return func(*args, **kwargs)
+        else:
+            return func(self_or_None, *args, **kwargs)
+
+    @wraps(func)
+    def wrapper_impl(*args, **kwargs):
+        # remove self from args if it is a class method
+        if inspect.isfunction(func) and "." in func.__qualname__:
+            self = args[0]
+            args = args[1:]
+        else:
+            self = None
 
-    Notes
-    -----
-    Queue will not be changed if provided explicitly.
-    """
+        # Check if the function is KNeighborsClassifier.fit
+        override_raw_input = (
+            self
+            and self.__class__.__name__ in ("KNeighborsClassifier", "KNeighborsRegressor")
+            and func.__name__ == "fit"
+        )
+        if _get_config()["use_raw_input"] is True and not override_raw_input:
+            if "queue" not in kwargs:
+                usm_iface = getattr(args[0], "__sycl_usm_array_interface__", None)
+                data_queue = usm_iface["syclobj"] if usm_iface is not None else None
+                kwargs["queue"] = data_queue
+            return invoke_func(self, *args, **kwargs)
+        elif len(args) == 0 and len(kwargs) == 0:
+            # no arguments, there's nothing we can deduce from them -> just call the function
+            return invoke_func(self, *args, **kwargs)
+
+        data = (*args, *kwargs.values())
+        # get and set the global queue from the kwarg or data
+        with QM.manage_global_queue(kwargs.get("queue"), *args) as queue:
+            hostargs, hostkwargs = _get_host_inputs(*args, **kwargs)
+            if "queue" in inspect.signature(func).parameters:
+                # set the queue if it's expected by func
+                hostkwargs["queue"] = queue
+            result = invoke_func(self, *hostargs, **hostkwargs)
 
-    def decorator(func):
-        def wrapper_impl(obj, *args, **kwargs):
-            if len(args) == 0 and len(kwargs) == 0:
-                return _run_on_device(func, obj, *args, **kwargs)
-            data = (*args, *kwargs.values())
-            data_queue, hostargs, hostkwargs = _get_host_inputs(*args, **kwargs)
-            if queue_param and not (
-                "queue" in hostkwargs and hostkwargs["queue"] is not None
-            ):
-                hostkwargs["queue"] = data_queue
-            result = _run_on_device(func, obj, *hostargs, **hostkwargs)
             usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
-            if usm_iface is not None:
-                result = _copy_to_usm(data_queue, result)
+            if queue is not None and usm_iface is not None:
+                result = _copy_to_usm(queue, result)
                 if dpnp_available and isinstance(data[0], dpnp.ndarray):
                     result = _convert_to_dpnp(result)
                 return result
-            config = get_config()
-            if not ("transform_output" in config and config["transform_output"]):
-                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
-                if input_array_api:
-                    input_array_api_device = data[0].device
-                    result = _asarray(
-                        result, input_array_api, device=input_array_api_device
-                    )
-            return result
-
-        if freefunc:
-
-            @wraps(func)
-            def wrapper_free(*args, **kwargs):
-                return wrapper_impl(None, *args, **kwargs)
-
-            return wrapper_free
-
-        @wraps(func)
-        def wrapper_with_self(self, *args, **kwargs):
-            return wrapper_impl(self, *args, **kwargs)
 
-        return wrapper_with_self
+        if not get_config().get("transform_output"):
+            input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+            if input_array_api:
+                input_array_api_device = data[0].device
+                result = _asarray(result, input_array_api, device=input_array_api_device)
+        return result
 
-    return decorator
+    return wrapper_impl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/basic_statistics/basic_statistics.py

@@ -14,23 +14,27 @@
 # limitations under the License.
 # ==============================================================================
 
-import warnings
 from abc import ABCMeta, abstractmethod
 
 import numpy as np
 
-from ..common._base import BaseEstimator
+from onedal._device_offload import supports_queue
+
+from .._config import _get_config
+from ..common._backend import bind_default_backend
 from ..datatypes import from_table, to_table
-from ..utils import _is_csr
-from ..utils.validation import _check_array
+from ..utils.validation import _check_array, _is_csr
 
 
-class BaseBasicStatistics(BaseEstimator, metaclass=ABCMeta):
+class BaseBasicStatistics(metaclass=ABCMeta):
     @abstractmethod
     def __init__(self, result_options, algorithm):
         self.options = result_options
         self.algorithm = algorithm
 
+    @bind_default_backend("basic_statistics")
+    def compute(self, params, data_table, weights_table): ...
+
     @staticmethod
     def get_all_result_options():
         return [
@@ -71,22 +75,25 @@ class BasicStatistics(BaseBasicStatistics):
     def __init__(self, result_options="all", algorithm="by_default"):
         super().__init__(result_options, algorithm)
 
+    @supports_queue
     def fit(self, data, sample_weight=None, queue=None):
-        policy = self._get_policy(queue, data, sample_weight)
-
         is_csr = _is_csr(data)
 
-        if data is not None and not is_csr:
-            data = _check_array(data, ensure_2d=False)
-        if sample_weight is not None:
-            sample_weight = _check_array(sample_weight, ensure_2d=False)
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            if data is not None and not is_csr:
+                data = _check_array(data, ensure_2d=False)
+            if sample_weight is not None:
+                sample_weight = _check_array(sample_weight, ensure_2d=False)
 
         is_single_dim = data.ndim == 1
 
         data_table, weights_table = to_table(data, sample_weight, queue=queue)
 
         dtype = data_table.dtype
-        raw_result = self._compute_raw(data_table, weights_table, policy, dtype, is_csr)
+        raw_result = raw_result = self._compute_raw(
+            data_table, weights_table, dtype, is_csr
+        )
         for opt, raw_value in raw_result.items():
             value = from_table(raw_value).ravel()
             if is_single_dim:
@@ -96,12 +103,9 @@ class BasicStatistics(BaseBasicStatistics):
 
         return self
 
-    def _compute_raw(
-        self, data_table, weights_table, policy, dtype=np.float32, is_csr=False
-    ):
-        module = self._get_backend("basic_statistics")
+    def _compute_raw(self, data_table, weights_table, dtype=np.float32, is_csr=False):
         params = self._get_onedal_params(is_csr, dtype)
-        result = module.compute(policy, params, data_table, weights_table)
+        result = self.compute(params, data_table, weights_table)
         options = self._get_result_options(self.options).split("|")
 
         return {opt: getattr(result, opt) for opt in options}

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/basic_statistics/incremental_basic_statistics.py

@@ -1,4 +1,3 @@
-# ==============================================================================
 # Copyright 2024 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,9 +16,14 @@
 import numpy as np
 
 from daal4py.sklearn._utils import get_dtype
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
 
+from .._config import _get_config
 from ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 from .basic_statistics import BaseBasicStatistics
 
 
@@ -68,12 +72,22 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
     def __init__(self, result_options="all"):
         super().__init__(result_options, algorithm="by_default")
         self._reset()
+        self._queue = None
+
+    @bind_default_backend("basic_statistics")
+    def partial_compute_result(self): ...
+
+    @bind_default_backend("basic_statistics")
+    def partial_compute(self, *args, **kwargs): ...
+
+    @bind_default_backend("basic_statistics")
+    def finalize_compute(self, *args, **kwargs): ...
 
     def _reset(self):
         self._need_to_finalize = False
-        self._partial_result = self._get_backend(
-            "basic_statistics", None, "partial_compute_result"
-        )
+        self._queue = None
+        # get the _partial_result pointer from backend
+        self._partial_result = self.partial_compute_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -85,6 +99,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
 
         return data
 
+    @supports_queue
     def partial_fit(self, X, weights=None, queue=None):
         """
         Computes partial data for basic statistics
@@ -104,40 +119,40 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         self : object
             Returns the instance itself.
         """
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+
+        # All data should use the same sycl queue
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+
         self._queue = queue
-        policy = self._get_policy(queue, X)
 
-        X = _check_array(
-            X, dtype=[np.float64, np.float32], ensure_2d=False, force_all_finite=False
-        )
-        if weights is not None:
-            weights = _check_array(
-                weights,
-                dtype=[np.float64, np.float32],
-                ensure_2d=False,
-                force_all_finite=False,
+        if not use_raw_input:
+            X = _check_array(
+                X, dtype=[np.float64, np.float32], ensure_2d=False, force_all_finite=False
             )
+            if weights is not None:
+                weights = _check_array(
+                    weights,
+                    dtype=[np.float64, np.float32],
+                    ensure_2d=False,
+                    force_all_finite=False,
+                )
 
         if not hasattr(self, "_onedal_params"):
             dtype = get_dtype(X)
             self._onedal_params = self._get_onedal_params(False, dtype=dtype)
 
         X_table, weights_table = to_table(X, weights, queue=queue)
-        self._partial_result = self._get_backend(
-            "basic_statistics",
-            None,
-            "partial_compute",
-            policy,
-            self._onedal_params,
-            self._partial_result,
-            X_table,
-            weights_table,
+        self._partial_result = self.partial_compute(
+            self._onedal_params, self._partial_result, X_table, weights_table
         )
 
         self._need_to_finalize = True
-        return self
+        self._queue = queue
 
-    def finalize_fit(self, queue=None):
+    def finalize_fit(self):
         """
         Finalizes basic statistics computation and obtains result
         attributes from the current `_partial_result`.
@@ -153,19 +168,9 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
             Returns the instance itself.
         """
         if self._need_to_finalize:
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-
-            result = self._get_backend(
-                "basic_statistics",
-                None,
-                "finalize_compute",
-                policy,
-                self._onedal_params,
-                self._partial_result,
-            )
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_compute(self._onedal_params, self._partial_result)
+
             options = self._get_result_options(self.options).split("|")
             for opt in options:
                 setattr(self, opt, from_table(getattr(result, opt)).ravel())

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/cluster/dbscan.py

@@ -16,15 +16,18 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import get_dtype, make2d
+from daal4py.sklearn._utils import make2d
+from onedal._device_offload import supports_queue
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
+from ..common._backend import bind_default_backend
 from ..common._mixin import ClusterMixin
 from ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 
 
-class BaseDBSCAN(BaseEstimator, ClusterMixin):
+class DBSCAN(ClusterMixin):
     def __init__(
         self,
         eps=0.5,
@@ -46,6 +49,9 @@ class BaseDBSCAN(BaseEstimator, ClusterMixin):
         self.p = p
         self.n_jobs = n_jobs
 
+    @bind_default_backend("dbscan.clustering")
+    def compute(self, params, data_table, weights_table): ...
+
     def _get_onedal_params(self, dtype=np.float32):
         return {
             "fptype": dtype,
@@ -56,50 +62,37 @@ class BaseDBSCAN(BaseEstimator, ClusterMixin):
             "result_options": "core_observation_indices|responses",
         }
 
-    def _fit(self, X, y, sample_weight, module, queue):
-        policy = self._get_policy(queue, X)
-        X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
-        sample_weight = make2d(sample_weight) if sample_weight is not None else None
+    @supports_queue
+    def fit(self, X, y=None, sample_weight=None, queue=None):
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+
+        if not use_raw_input:
+            X = _check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
+            X = make2d(X)
+        elif sua_iface is not None:
+            queue = X.sycl_queue
+
         X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
         params = self._get_onedal_params(X_table.dtype)
-        result = module.compute(policy, params, X_table, sample_weight_table)
+        result = self.compute(params, X_table, sample_weight_table)
 
-        self.labels_ = from_table(result.responses).ravel()
-        if result.core_observation_indices is not None:
+        self.labels_ = from_table(result.responses, sycl_queue=queue).ravel()
+        if (
+            result.core_observation_indices is not None
+            and not result.core_observation_indices.kind == "empty"
+        ):
             self.core_sample_indices_ = from_table(
-                result.core_observation_indices
+                result.core_observation_indices,
+                sycl_queue=queue,
             ).ravel()
         else:
-            self.core_sample_indices_ = np.array([], dtype=np.intc)
-        self.components_ = np.take(X, self.core_sample_indices_, axis=0)
+            # construct keyword arguments for different namespaces (dptcl takes sycl_queue)
+            kwargs = {"dtype": xp.int32}  # always the same
+            if xp is not np:
+                kwargs["sycl_queue"] = queue
+            self.core_sample_indices_ = xp.empty((0,), **kwargs)
+        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
         self.n_features_in_ = X.shape[1]
         return self
-
-
-class DBSCAN(BaseDBSCAN):
-    def __init__(
-        self,
-        eps=0.5,
-        *,
-        min_samples=5,
-        metric="euclidean",
-        metric_params=None,
-        algorithm="auto",
-        leaf_size=30,
-        p=None,
-        n_jobs=None,
-    ):
-        self.eps = eps
-        self.min_samples = min_samples
-        self.metric = metric
-        self.metric_params = metric_params
-        self.algorithm = algorithm
-        self.leaf_size = leaf_size
-        self.p = p
-        self.n_jobs = n_jobs
-
-    def fit(self, X, y=None, sample_weight=None, queue=None):
-        return super()._fit(
-            X, y, sample_weight, self._get_backend("dbscan", "clustering", None), queue
-        )