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

scikit_learn_intelex-2025.5.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.5.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.5.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.5.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

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

@@ -13,12 +13,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ===============================================================================
+
 import numpy as np
 
-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 .._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 .covariance import BaseEmpiricalCovariance
 
 
@@ -55,12 +61,21 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
     def __init__(self, method="dense", bias=False, assume_centered=False):
         super().__init__(method, bias, assume_centered)
         self._reset()
+        self._queue = None
+
+    @bind_default_backend("covariance")
+    def partial_compute(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("covariance")
+    def partial_compute_result(self): ...
+
+    @bind_default_backend("covariance")
+    def finalize_compute(self, params, partial_result): ...
 
     def _reset(self):
         self._need_to_finalize = False
-        self._partial_result = self._get_backend(
-            "covariance", None, "partial_compute_result"
-        )
+        self._queue = None
+        self._partial_result = self.partial_compute_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -73,6 +88,7 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
 
         return data
 
+    @supports_queue
     def partial_fit(self, X, y=None, queue=None):
         """
         Computes partial data for the covariance matrix
@@ -95,30 +111,27 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
-
-        self._queue = queue
+        use_raw_input = _get_config()["use_raw_input"] is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
 
-        policy = self._get_policy(queue, 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], ensure_2d=True)
 
+        self._queue = queue
         X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
             self._dtype = X_table.dtype
 
         params = self._get_onedal_params(self._dtype)
-        self._partial_result = self._get_backend(
-            "covariance",
-            None,
-            "partial_compute",
-            policy,
-            params,
-            self._partial_result,
-            X_table,
-        )
+        self._partial_result = self.partial_compute(params, self._partial_result, X_table)
         self._need_to_finalize = True
+        # store the queue for when we finalize
+        self._queue = queue
 
-    def finalize_fit(self, queue=None):
+    def finalize_fit(self):
         """
         Finalizes covariance matrix and obtains `covariance_` and `location_`
         attributes from the current `_partial_result`.
@@ -135,19 +148,9 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         """
         if self._need_to_finalize:
             params = self._get_onedal_params(self._dtype)
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-
-            result = self._get_backend(
-                "covariance",
-                None,
-                "finalize_compute",
-                policy,
-                params,
-                self._partial_result,
-            )
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_compute(params, self._partial_result)
+
             if daal_check_version((2024, "P", 1)) or (not self.bias):
                 self.covariance_ = from_table(result.cov_matrix)
             else:

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

@@ -14,11 +14,9 @@
 # limitations under the License.
 # ==============================================================================
 
-import warnings
-
 import numpy as np
 
-from onedal import _backend, _is_dpc_backend
+from onedal import _default_backend as backend
 
 
 def _apply_and_pass(func, *args, **kwargs):
@@ -29,7 +27,7 @@ def _apply_and_pass(func, *args, **kwargs):
 
 def _convert_one_to_table(arg, queue=None):
     # All inputs for table conversion must be array-like or sparse, not scalars
-    return _backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
+    return backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
 
 
 def to_table(*args, queue=None):
@@ -54,7 +52,7 @@ def to_table(*args, queue=None):
     return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
 
 
-if _is_dpc_backend:
+if backend.is_dpc:
 
     try:
         # try/catch is used here instead of dpep_helpers because
@@ -79,8 +77,6 @@ if _is_dpc_backend:
         def _table_to_array(table, xp=None):
             return xp.asarray(table)
 
-    from ..common._policy import _HostInteropPolicy
-
     def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
         # Currently only `__sycl_usm_array_interface__` protocol used to
         # convert into dpnp/dpctl tensors.
@@ -96,12 +92,12 @@ if _is_dpc_backend:
                 # Host tables first converted into numpy.narrays and then to array from xp
                 # namespace.
                 return xp.asarray(
-                    _backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
+                    backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
                 )
             else:
                 return _table_to_array(table, xp=xp)
 
-        return _backend.from_table(table)
+        return backend.from_table(table)
 
 else:
 
@@ -112,7 +108,7 @@ else:
             raise RuntimeError(
                 "SYCL usm array conversion from table requires the DPC backend"
             )
-        return _backend.from_table(table)
+        return backend.from_table(table)
 
 
 def from_table(*args, sycl_queue=None, sua_iface=None, xp=None):