scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/cluster/kmeans_init.py

@@ -15,18 +15,52 @@
 # ==============================================================================
 
 import numpy as np
-from scipy.sparse import issparse
 from sklearn.utils import check_random_state
 
-from daal4py.sklearn._utils import daal_check_version, get_dtype
+from daal4py.sklearn._utils import daal_check_version
+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 sklearnex._config import config_context, get_config
 
-from ..common._base import BaseEstimator as onedal_BaseEstimator
 from ..datatypes import from_table, to_table
-from ..utils import _check_array
+from ..utils.validation import _check_array
 
 if daal_check_version((2023, "P", 200)):
 
-    class KMeansInit(onedal_BaseEstimator):
+    def force_host_if_csr(func):
+        """
+        Decorator to force computation on the host if the input data is in CSR format.
+
+        CSR (Compressed Sparse Row) format is not supported on GPU. This decorator ensures that
+        the computation is performed on the host (CPU) when the input data is in CSR format.
+        It is necessary that `self.is_csr` is to the correct value (True or False) before calling.
+        It temporarily modifies the configuration to target the CPU and removes the global SYCL queue
+        to ensure the computation is executed on the host. The original configuration is restored upon exit.
+
+        Parameters:
+        func (function): The function to be decorated.
+
+        Returns:
+        function: The wrapped function with the modified configuration if the input data is in CSR format.
+        """
+        config = get_config()
+        # `auto` rather than `cpu` is necessary in order to force host when a SYCL cpu target is unavailable
+        config["target_offload"] = "auto"
+
+        def wrapper(self, *args, **kwargs):
+            if self.is_csr:
+                with (
+                    config_context(**config),
+                    QM.manage_global_queue(None, None),
+                ):
+                    return func(self, *args, **kwargs)
+            else:
+                return func(self, *args, **kwargs)
+
+        return wrapper
+
+    class KMeansInit:
         """
         KMeansInit oneDAL implementation.
         """
@@ -37,17 +71,22 @@ if daal_check_version((2023, "P", 200)):
             seed=777,
             local_trials_count=None,
             algorithm="plus_plus_dense",
+            is_csr=False,
         ):
             self.cluster_count = cluster_count
             self.seed = seed
             self.local_trials_count = local_trials_count
             self.algorithm = algorithm
+            self.is_csr = is_csr
 
             if local_trials_count is None:
                 self.local_trials_count = 2 + int(np.log(cluster_count))
             else:
                 self.local_trials_count = local_trials_count
 
+        @bind_default_backend("kmeans_init.init", lookup_name="compute")
+        def backend_compute(self, params, X_table): ...
+
         def _get_onedal_params(self, dtype=np.float32):
             return {
                 "fptype": dtype,
@@ -68,31 +107,25 @@ if daal_check_version((2023, "P", 200)):
             params = self._get_onedal_params(X.dtype)
             return (params, X, X.dtype)
 
-        def _compute_raw(self, X_table, module, policy, dtype=np.float32):
+        def _compute_raw(self, X_table, dtype=np.float32):
             params = self._get_onedal_params(dtype)
-
-            result = module.compute(policy, params, X_table)
-
+            result = self.backend_compute(params, X_table)
             return result.centroids
 
-        def _compute(self, X, module, queue):
-            policy = self._get_policy(queue, X)
-            # oneDAL KMeans Init for sparse data does not have GPU support
-            if issparse(X):
-                policy = self._get_policy(None, None)
-            _, X_table, dtype = self._get_params_and_input(X, queue)
-
-            centroids = self._compute_raw(X_table, module, policy, dtype)
-
+        def _compute(self, X):
+            _, X_table, dtype = self._get_params_and_input(X, queue=QM.get_global_queue())
+            centroids = self._compute_raw(X_table, dtype)
             return from_table(centroids)
 
-        def compute_raw(self, X_table, policy, dtype=np.float32):
-            return self._compute_raw(
-                X_table, self._get_backend("kmeans_init", "init", None), policy, dtype
-            )
+        @force_host_if_csr
+        def compute_raw(self, X_table, dtype=np.float32, queue=None):
+            # no @supports_queue decorator here, because we only accept X_table that has no queue information
+            return self._compute_raw(X_table, dtype)
 
+        @force_host_if_csr
+        @supports_queue
         def compute(self, X, queue=None):
-            return self._compute(X, self._get_backend("kmeans_init", "init", None), queue)
+            return self._compute(X)
 
     def kmeans_plusplus(
         X,
@@ -107,6 +140,6 @@ if daal_check_version((2023, "P", 200)):
         return (
             KMeansInit(
                 n_clusters, seed=random_seed, local_trials_count=n_local_trials
-            ).compute(X, queue),
+            ).compute(X, queue=queue),
             np.full(n_clusters, -1),
         )

scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/onedal/common/_backend.py

@@ -0,0 +1,233 @@
+# ==============================================================================
+# 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 logging
+from typing import Any, Callable, Literal, Optional
+
+from onedal import Backend, _default_backend, _spmd_backend
+from onedal.utils import _sycl_queue_manager as QM
+
+logger = logging.getLogger("sklearnex")
+
+# define types for backend functions: default, dpc, spmd
+BackendType = Literal["none", "host", "dpc", "spmd"]
+
+
+class BackendManager:
+    def __init__(self, backend_module):
+        self.backend = backend_module
+
+    def get_backend_type(self) -> BackendType:
+        if self.backend is None:
+            return "none"
+        if self.backend.is_spmd:
+            return "spmd"
+        if self.backend.is_dpc:
+            return "dpc"
+        return "host"
+
+    def get_backend_component(self, module_name: str, component_name: str):
+        """Get a component of the backend module.
+
+        Args:
+            module(str): The module to get the component from.
+            component: The component to get from the module.
+
+        Returns:
+            The component of the module.
+        """
+        submodules = module_name.split(".")
+        module = getattr(self.backend, submodules[0])
+        for submodule in submodules[1:]:
+            module = getattr(module, submodule)
+
+        # component can be provided like submodule.method, there can be arbitrary number of submodules
+        # and methods
+        result = module
+        for part in component_name.split("."):
+            result = getattr(result, part)
+
+        return result
+
+
+default_manager = BackendManager(_default_backend)
+spmd_manager = BackendManager(_spmd_backend)
+
+
+class BackendFunction:
+    """Wrapper around backend function to allow setting auxiliary information"""
+
+    def __init__(
+        self,
+        method: Callable[..., Any],
+        backend: Backend,
+        name: str,
+        no_policy: bool,
+    ):
+        self.method = method
+        self.name = name
+        self.backend = backend
+        self.no_policy = no_policy
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Dispatch to backend function with the appropriate policy which is determined from the global queue"""
+        if not args and not kwargs:
+            # immediate dispatching without any arguments, in particular no policy
+            return self.method()
+
+        if self.no_policy:
+            return self.method(*args, **kwargs)
+
+        # use globally configured queue (from `target_offload` configuration or provided data)
+        queue = QM.get_global_queue()
+
+        if queue is not None and not (self.backend.is_dpc or self.backend.is_spmd):
+            raise RuntimeError("Operations using queues require the DPC/SPMD backend")
+
+        if self.backend.is_spmd and queue is None:
+            raise RuntimeError("Executing functions from SPMD backend requires a queue")
+
+        # craft the correct policy including the device queue
+        if queue is None:
+            policy = self.backend.host_policy()
+        elif self.backend.is_spmd:
+            policy = self.backend.spmd_data_parallel_policy(queue)
+        elif self.backend.is_dpc:
+            policy = self.backend.data_parallel_policy(queue)
+        else:
+            policy = self.backend.host_policy()
+
+        logger.debug(
+            f"Dispatching function '{self.name}' with policy {policy} to {self.backend}"
+        )
+
+        # dispatch to backend function
+        return self.method(policy, *args, **kwargs)
+
+    def __repr__(self) -> str:
+        return f"BackendFunction({self.backend}.{self.name})"
+
+
+def __decorator(
+    method: Callable[..., Any],
+    backend_manager: BackendManager,
+    module_name: str,
+    lookup_name: Optional[str],
+    no_policy: bool,
+) -> Callable[..., Any]:
+    """Decorator to bind a method to the specified backend"""
+    if lookup_name is None:
+        lookup_name = method.__name__
+
+    if backend_manager.get_backend_type() == "none":
+        raise RuntimeError("Internal __decorator() should not be called with no backend")
+
+    backend_method = backend_manager.get_backend_component(module_name, lookup_name)
+    wrapped_method = BackendFunction(
+        backend_method,
+        backend_manager.backend,
+        name=f"{module_name}.{method.__name__}",
+        no_policy=no_policy,
+    )
+
+    backend_type = backend_manager.get_backend_type()
+    logger.debug(
+        f"Assigned method '<{backend_type}_backend>.{module_name}.{lookup_name}' to '{method.__qualname__}'"
+    )
+
+    return wrapped_method
+
+
+def bind_default_backend(
+    module_name: str, lookup_name: Optional[str] = None, no_policy=False
+):
+    """
+    Decorator to bind a method from the default backend to a class.
+
+    This decorator binds a method implementation from the default backend (host/dpc).
+    If the default backend is unavailable, the method is returned without modification.
+
+    Parameters:
+    ----------
+    module_name : str
+        The name of the module where the target function is located (e.g. `covariance`).
+    lookup_name : Optional[str], optional
+        The name of the method to look up in the backend module. If not provided,
+        the name of the decorated method is used.
+    no_policy : bool, optional
+        If True, the method will be decorated without a policy. Default is False.
+
+    Returns:
+    -------
+    Callable[..., Any]
+        The decorated method bound to the implementation in default backend, or the original
+        method if the default backend is unavailable.
+    """
+
+    def decorator(method: Callable[..., Any]):
+        # grab the lookup_name from outer scope
+        nonlocal lookup_name
+
+        if _default_backend is None:
+            logger.debug(
+                f"Default backend unavailable, skipping decoration for '{method.__name__}'"
+            )
+            return method
+
+        return __decorator(method, default_manager, module_name, lookup_name, no_policy)
+
+    return decorator
+
+
+def bind_spmd_backend(
+    module_name: str, lookup_name: Optional[str] = None, no_policy=False
+):
+    """
+    Decorator to bind a method from the SPMD backend to a class.
+
+    This decorator binds a method implementation from the SPMD backend.
+    If the SPMD backend is unavailable, the method is returned without modification.
+
+    Parameters:
+    ----------
+    module_name : str
+        The name of the module where the target function is located (e.g. `covariance`).
+    lookup_name : Optional[str], optional
+        The name of the method to look up in the backend module. If not provided,
+        the name of the decorated method is used.
+    no_policy : bool, optional
+        If True, the method will be decorated without a policy. Default is False.
+
+    Returns:
+    -------
+    Callable[..., Any]
+        The decorated method bound to the implementation in SPMD backend, or the original
+        method if the SPMD backend is unavailable.
+    """
+
+    def decorator(method: Callable[..., Any]):
+        # grab the lookup_name from outer scope
+        nonlocal lookup_name
+
+        if _spmd_backend is None:
+            logger.debug(
+                f"SPMD backend unavailable, skipping decoration for '{method.__name__}'"
+            )
+            return method
+
+        return __decorator(method, spmd_manager, module_name, lookup_name, no_policy)
+
+    return decorator

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/common/hyperparameters.py

@@ -19,7 +19,7 @@ from typing import Any, Dict, Tuple
 from warnings import warn
 
 from daal4py.sklearn._utils import daal_check_version
-from onedal import _backend
+from onedal import _default_backend as backend
 
 if not daal_check_version((2024, "P", 0)):
     warn("Hyperparameters are supported in oneDAL starting from 2024.0.0 version.")
@@ -98,11 +98,11 @@ else:
         (
             "linear_regression",
             "train",
-        ): _backend.linear_model.regression.train_hyperparameters(),
-        ("covariance", "compute"): _backend.covariance.compute_hyperparameters(),
+        ): backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): backend.covariance.compute_hyperparameters(),
     }
     if daal_check_version((2024, "P", 300)):
-        df_infer_hp = _backend.decision_forest.infer_hyperparameters
+        df_infer_hp = backend.decision_forest.infer_hyperparameters
         hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
     hyperparameters_map = {}
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -14,16 +14,15 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
 import pytest
 
-from onedal import _backend, _is_dpc_backend
+from onedal import _default_backend as backend
 from onedal.tests.utils._device_selection import get_queues
 from onedal.utils._dpep_helpers import dpctl_available
 
 
 @pytest.mark.skipif(
-    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
 )
 @pytest.mark.parametrize("device_type", ["cpu", "gpu"])
 @pytest.mark.parametrize("device_number", [None, 0, 1, 2, 3])
@@ -32,7 +31,7 @@ def test_sycl_queue_string_creation(device_type, device_number):
     from dpctl import SyclQueue
     from dpctl._sycl_queue import SyclQueueCreationError
 
-    onedal_SyclQueue = _backend.SyclQueue
+    onedal_SyclQueue = backend.SyclQueue
 
     device = (
         ":".join([device_type, str(device_number)])
@@ -63,14 +62,14 @@ def test_sycl_queue_string_creation(device_type, device_number):
 
 
 @pytest.mark.skipif(
-    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
 )
 @pytest.mark.parametrize("queue", get_queues())
 def test_sycl_queue_conversion(queue):
     if queue is None:
         pytest.skip("Not a dpctl queue")
     SyclQueue = queue.__class__
-    onedal_SyclQueue = _backend.SyclQueue
+    onedal_SyclQueue = backend.SyclQueue
 
     q = onedal_SyclQueue(queue)
 
@@ -83,7 +82,7 @@ def test_sycl_queue_conversion(queue):
 
 
 @pytest.mark.skipif(
-    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
 )
 @pytest.mark.parametrize("queue", get_queues())
 def test_sycl_device_attributes(queue):
@@ -91,7 +90,7 @@ def test_sycl_device_attributes(queue):
 
     if queue is None:
         pytest.skip("Not a dpctl queue")
-    onedal_SyclQueue = _backend.SyclQueue
+    onedal_SyclQueue = backend.SyclQueue
 
     onedal_queue = onedal_SyclQueue(queue)
 
@@ -107,17 +106,17 @@ def test_sycl_device_attributes(queue):
     assert onedal_queue.sycl_device.filter_string in queue.sycl_device.filter_string
 
 
-@pytest.mark.skipif(not _is_dpc_backend, reason="requires dpc backend")
+@pytest.mark.skipif(not backend.is_dpc, reason="requires dpc backend")
 def test_backend_queue():
     try:
-        q = _backend.SyclQueue("cpu")
+        q = backend.SyclQueue("cpu")
     except RuntimeError:
         pytest.skip("OpenCL CPU runtime not installed")
 
     # verify copying via a py capsule object is functional
-    q2 = _backend.SyclQueue(q._get_capsule())
+    q2 = backend.SyclQueue(q._get_capsule())
     # verify copying via the _get_capsule attribute
-    q3 = _backend.SyclQueue(q)
+    q3 = backend.SyclQueue(q)
 
     q_array = [q, q2, q3]
 
@@ -126,3 +125,19 @@ def test_backend_queue():
     assert all([queue.sycl_device.is_cpu for queue in q_array])
     assert all([not queue.sycl_device.is_gpu for queue in q_array])
     assert all(["cpu" in queue.sycl_device.filter_string for queue in q_array])
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+def test_backend_device_id():
+    """verify dpctl device id matches our internal device id"""
+    import dpctl
+
+    for i in range(dpctl.get_num_devices()):
+        device = dpctl.SyclDevice(str(i))
+        if device.is_gpu or device.is_cpu:
+            backend_device = backend.SyclDevice(i)
+            assert (
+                i == backend_device.get_device_id()
+            ), f"backend id does not match device_id: {i}"

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/covariance/covariance.py

@@ -17,20 +17,27 @@ from abc import ABCMeta
 
 import numpy as np
 
-from daal4py.sklearn._utils import daal_check_version, get_dtype
-from onedal.utils import _check_array
+from daal4py.sklearn._utils import daal_check_version
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils.validation import _check_array
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
 from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
 
 
-class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
+class BaseEmpiricalCovariance(metaclass=ABCMeta):
     def __init__(self, method="dense", bias=False, assume_centered=False):
         self.method = method
         self.bias = bias
         self.assume_centered = assume_centered
 
+    @bind_default_backend("covariance")
+    def compute(self, *args, **kwargs): ...
+
     def _get_onedal_params(self, dtype=np.float32):
         params = {
             "fptype": dtype,
@@ -73,6 +80,7 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         Estimated covariance matrix
     """
 
+    @supports_queue
     def fit(self, X, y=None, queue=None):
         """Fit the sample covariance matrix of X.
 
@@ -93,30 +101,30 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        policy = self._get_policy(queue, X)
-        X = _check_array(X, dtype=[np.float64, np.float32])
+        use_raw_input = _get_config()["use_raw_input"] is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+
+        if not use_raw_input:
+            X = _check_array(X, dtype=[np.float64, np.float32])
         X = to_table(X, queue=queue)
+
         params = self._get_onedal_params(X.dtype)
         hparams = get_hyperparameters("covariance", "compute")
         if hparams is not None and not hparams.is_default:
-            result = self._get_backend(
-                "covariance",
-                None,
-                "compute",
-                policy,
-                params,
-                hparams.backend,
-                X,
-            )
+            result = self.compute(params, hparams.backend, X)
         else:
-            result = self._get_backend("covariance", None, "compute", policy, params, X)
+            result = self.compute(params, X)
         if daal_check_version((2024, "P", 1)) or (not self.bias):
-            self.covariance_ = from_table(result.cov_matrix)
+            self.covariance_ = from_table(result.cov_matrix, sycl_queue=queue)
         else:
             self.covariance_ = (
-                from_table(result.cov_matrix) * (X.shape[0] - 1) / X.shape[0]
+                from_table(result.cov_matrix, sycl_queue=queue)
+                * (X.shape[0] - 1)
+                / X.shape[0]
             )
 
-        self.location_ = from_table(result.means).ravel()
+        self.location_ = from_table(result.means, sycl_queue=queue).ravel()
 
         return self