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

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/_device_offload.py

@@ -16,34 +16,41 @@
 
 import inspect
 import logging
-from collections.abc import Iterable
 from functools import wraps
 
 import numpy as np
 from sklearn import get_config
 
+from onedal import _default_backend as backend
+
 from ._config import _get_config
+from .datatypes import copy_to_dpnp, copy_to_usm, usm_to_numpy
 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.memory import MemoryUSMDevice, as_usm_memory
-    from dpctl.tensor import usm_ndarray
-else:
-    from onedal import _dpc_backend
-
-    SyclQueue = getattr(_dpc_backend, "SyclQueue", None)
+from .utils._third_party import is_dpnp_ndarray
 
 logger = logging.getLogger("sklearnex")
+cpu_dlpack_device = (backend.kDLCPU, 0)
 
 
 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).
+    """Decorator that updates the global queue before function evaluation.
+
+    The global queue is updated 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).
+
+    Parameters
+    ----------
+        func : callable
+            Function to be wrapped for SYCL queue use in oneDAL.
+
+    Returns
+    -------
+        wrapper : callable
+            Wrapped function.
     """
 
     @wraps(func)
@@ -57,67 +64,37 @@ def supports_queue(func):
     return wrapper
 
 
-if dpnp_available:
-    import dpnp
-
-    from .utils._array_api import _convert_to_dpnp
-
-
-def _copy_to_usm(queue, array):
-    if not dpctl_available:
-        raise RuntimeError(
-            "dpctl need to be installed to work " "with __sycl_usm_array_interface__"
-        )
-
-    if hasattr(array, "__array__"):
-
-        try:
-            mem = MemoryUSMDevice(array.nbytes, queue=queue)
-            mem.copy_from_host(array.tobytes())
-            return usm_ndarray(array.shape, array.dtype, buffer=mem)
-        except ValueError as e:
-            # ValueError will raise if device does not support the dtype
-            # retry with float32 (needed for fp16 and fp64 support issues)
-            # try again as float32, if it is a float32 just raise the error.
-            if array.dtype == np.float32:
-                raise e
-            return _copy_to_usm(queue, array.astype(np.float32))
-    else:
-        if isinstance(array, Iterable):
-            array = [_copy_to_usm(queue, i) for i in array]
-        return array
-
-
 def _transfer_to_host(*data):
     has_usm_data, has_host_data = False, False
 
     host_data = []
     for item in data:
-        usm_iface = getattr(item, "__sycl_usm_array_interface__", None)
-        array_api = getattr(item, "__array_namespace__", lambda: None)()
-        if usm_iface is not None:
-            if not dpctl_available:
-                raise RuntimeError(
-                    "dpctl need to be installed to work "
-                    "with __sycl_usm_array_interface__"
-                )
-
-            buffer = as_usm_memory(item).copy_to_host()
-            order = "C"
-            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(
-                shape=usm_iface["shape"],
-                dtype=usm_iface["typestr"],
-                buffer=buffer,
-                order=order,
-            )
+        if usm_iface := getattr(item, "__sycl_usm_array_interface__", None):
+            item = usm_to_numpy(item, usm_iface)
             has_usm_data = True
-        elif array_api and not _is_numpy_namespace(array_api):
-            # `copy`` param for the `asarray`` is not setted.
-            # The object is copied only if needed.
-            item = np.asarray(item)
+        elif not isinstance(item, np.ndarray) and (
+            device := getattr(item, "__dlpack_device__", None)
+        ):
+            # check dlpack data location.
+            if device() != cpu_dlpack_device:
+                if hasattr(item, "to_device"):
+                    # use of the "cpu" string as device not officially part of
+                    # the array api standard but widely supported
+                    item = item.to_device("cpu")
+                elif hasattr(item, "to"):
+                    # pytorch-specific fix as it is not array api compliant
+                    item = item.to("cpu")
+                else:
+                    raise TypeError(f"cannot move {type(item)} to cpu")
+
+            # convert to numpy
+            if hasattr(item, "__array__"):
+                # `copy`` param for the `asarray`` is not set.
+                # The object is copied only if needed
+                item = np.asarray(item)
+            else:
+                # requires numpy 1.23
+                item = np.from_dlpack(item)
             has_host_data = True
         else:
             has_host_data = True
@@ -140,10 +117,21 @@ def _get_host_inputs(*args, **kwargs):
 
 
 def support_input_format(func):
-    """
+    """Transform input and output function arrays to/from host.
+
     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
+    ----------
+    func : callable
+       Function or method which has array data as input.
+
+    Returns
+    -------
+    wrapper_impl : callable
+        Wrapped function or method which will return matching format.
     """
 
     def invoke_func(self_or_None, *args, **kwargs):
@@ -174,15 +162,16 @@ def support_input_format(func):
             )
         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
+                if usm_iface := getattr(args[0], "__sycl_usm_array_interface__", None):
+                    kwargs["queue"] = usm_iface["syclobj"]
+                else:
+                    kwargs["queue"] = None
             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())
+        data = (*args, *kwargs.values())[0]
         # 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)
@@ -191,17 +180,17 @@ def support_input_format(func):
                 hostkwargs["queue"] = queue
             result = invoke_func(self, *hostargs, **hostkwargs)
 
-            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
-            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
+            if queue and hasattr(data, "__sycl_usm_array_interface__"):
+                return (
+                    copy_to_dpnp(queue, result)
+                    if is_dpnp_ndarray(data)
+                    else copy_to_usm(queue, result)
+                )
 
         if get_config().get("transform_output") in ("default", None):
-            input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+            input_array_api = getattr(data, "__array_namespace__", lambda: None)()
             if input_array_api and not _is_numpy_namespace(input_array_api):
-                input_array_api_device = data[0].device
+                input_array_api_device = data.device
                 result = _asarray(result, input_array_api, device=input_array_api_device)
         return result
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/basic_statistics/basic_statistics.py

@@ -68,8 +68,53 @@ class BaseBasicStatistics(metaclass=ABCMeta):
 
 
 class BasicStatistics(BaseBasicStatistics):
-    """
-    Basic Statistics oneDAL implementation.
+    """Low order moments oneDAL estimator.
+
+    Calculate basic statistics for data.
+
+    Parameters
+    ----------
+    result_options : str or list, default=str('all')
+        List of statistics to compute.
+
+    algorithm : str, default=str('by_default')
+        Method for statistics computation.
+
+    Attributes
+    ----------
+        min : ndarray of shape (n_features,)
+            Minimum of each feature over all samples.
+
+        max : ndarray of shape (n_features,)
+            Maximum of each feature over all samples.
+
+        sum : ndarray of shape (n_features,)
+            Sum of each feature over all samples.
+
+        mean : ndarray of shape (n_features,)
+            Mean of each feature over all samples.
+
+        variance : ndarray of shape (n_features,)
+            Variance of each feature over all samples.
+
+        variation : ndarray of shape (n_features,)
+            Variation of each feature over all samples.
+
+        sum_squares : ndarray of shape (n_features,)
+            Sum of squares for each feature over all samples.
+
+        standard_deviation : ndarray of shape (n_features,)
+            Standard deviation of each feature over all samples.
+
+        sum_squares_centered : ndarray of shape (n_features,)
+            Centered sum of squares for each feature over all samples.
+
+        second_order_raw_moment : ndarray of shape (n_features,)
+            Second order moment of each feature over all samples.
+
+    Notes
+    -----
+        Attributes are populated only for corresponding result options.
     """
 
     def __init__(self, result_options="all", algorithm="by_default"):
@@ -77,6 +122,27 @@ class BasicStatistics(BaseBasicStatistics):
 
     @supports_queue
     def fit(self, data, sample_weight=None, queue=None):
+        """Generate statistics.
+
+        Parameters
+        ----------
+        data : array-like of shape (n_samples, n_features)
+            Training data batch, where `n_samples` is the number of samples
+            in the batch, and `n_features` is the number of features.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Individual weights for each sample.
+
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
         is_csr = _is_csr(data)
 
         use_raw_input = _get_config().get("use_raw_input", False) is True
@@ -91,9 +157,7 @@ class BasicStatistics(BaseBasicStatistics):
         data_table, weights_table = to_table(data, sample_weight, queue=queue)
 
         dtype = data_table.dtype
-        raw_result = raw_result = self._compute_raw(
-            data_table, weights_table, dtype, is_csr
-        )
+        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:

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/basic_statistics/incremental_basic_statistics.py

@@ -28,15 +28,16 @@ from .basic_statistics import BaseBasicStatistics
 
 
 class IncrementalBasicStatistics(BaseBasicStatistics):
-    """
-    Incremental estimator for basic statistics based on oneDAL implementation.
-    Allows to compute basic statistics if data are splitted into batches.
+    """Incremental oneDAL low order moments estimator.
+
+    Calculate basic statistics for data split into batches.
+
     Parameters
     ----------
-    result_options: string or list, default='all'
-        List of statistics to compute
+    result_options : str or list, default=str('all')
+        List of statistics to compute.
 
-    Attributes (are existing only if corresponding result option exists)
+    Attributes
     ----------
         min : ndarray of shape (n_features,)
             Minimum of each feature over all samples.
@@ -67,6 +68,10 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
 
         second_order_raw_moment : ndarray of shape (n_features,)
             Second order moment of each feature over all samples.
+
+    Notes
+    -----
+        Attributes are populated only for corresponding result options.
     """
 
     def __init__(self, result_options="all"):
@@ -101,9 +106,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
 
     @supports_queue
     def partial_fit(self, X, weights=None, queue=None):
-        """
-        Computes partial data for basic statistics
-        from data batch X and saves it to `_partial_result`.
+        """Generate partial statistics from batch data in `_partial_result`.
 
         Parameters
         ----------
@@ -111,8 +114,12 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
             Training data batch, where `n_samples` is the number of samples
             in the batch, and `n_features` is the number of features.
 
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        weights : array-like of shape (n_samples,), default=None
+            Individual weights for each sample.
+
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
 
         Returns
         -------
@@ -153,14 +160,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         self._queue = queue
 
     def finalize_fit(self):
-        """
-        Finalizes basic statistics computation and obtains result
-        attributes from the current `_partial_result`.
-
-        Parameters
-        ----------
-        queue : dpctl.SyclQueue
-            If not None, use this queue for computations.
+        """Finalize statistics from the current `_partial_result`.
 
         Returns
         -------

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/cluster/kmeans.py

@@ -449,6 +449,10 @@ class KMeans(_BaseKMeans):
         X : array-like of shape (n_samples, n_features)
             New data to predict.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         labels : ndarray of shape (n_samples,)
@@ -470,6 +474,10 @@ class KMeans(_BaseKMeans):
         y : Ignored
             Not used, present here for API consistency by convention.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         labels : ndarray of shape (n_samples,)
@@ -490,6 +498,10 @@ class KMeans(_BaseKMeans):
         y : Ignored
             Not used, present here for API consistency by convention.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         X_new : ndarray of shape (n_samples, n_clusters)
@@ -523,9 +535,13 @@ class KMeans(_BaseKMeans):
 
         Parameters
         ----------
-        X: {array-like, sparse matrix} of shape (n_samples, n_features)
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
             New data.
 
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
         Returns
         -------
         score: float

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/common/_backend.py

@@ -42,12 +42,18 @@ class BackendManager:
     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.
+        Parameters
+        ----------
+            module_name : str
+                The module to get the component from.
+
+            component_name : str
+                The component to get from the module.
+
+        Returns
+        -------
+            result : method, attribute or module
+                The component of the module.
         """
         submodules = module_name.split(".")
         module = getattr(self.backend, submodules[0])
@@ -68,7 +74,22 @@ spmd_manager = BackendManager(_spmd_backend)
 
 
 class BackendFunction:
-    """Wrapper around backend function to allow setting auxiliary information"""
+    """Wrapper around backend function to allow setting auxiliary information.
+
+    Parameters
+    ----------
+    method : callable
+        Pybind11 backend function.
+
+    backend : Backend
+        Encapsulated oneDAL pybind11 interface.
+
+    name : str
+        Name of function.
+
+    no_policy : bool
+       Flag that a oneDAL policy is not required for function evaluation.
+    """
 
     def __init__(
         self,
@@ -101,14 +122,7 @@ class BackendFunction:
             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()
+        policy = self.backend.get_policy(queue)
 
         logger.debug(
             f"Dispatching function '{self.name}' with policy {policy} to {self.backend}"
@@ -128,7 +142,7 @@ def __decorator(
     lookup_name: Optional[str],
     no_policy: bool,
 ) -> Callable[..., Any]:
-    """Decorator to bind a method to the specified backend"""
+    """Decorator to bind a method to the specified backend."""
     if lookup_name is None:
         lookup_name = method.__name__
 
@@ -157,24 +171,30 @@ def bind_default_backend(
     """
     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.
+    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:
+    Parameters
     ----------
     module_name : str
-        The name of the module where the target function is located (e.g. `covariance`).
+        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.
+        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.
+        If 'True', the method will be decorated without a policy. Default is
+        False.
 
-    Returns:
+    Returns
     -------
-    Callable[..., Any]
-        The decorated method bound to the implementation in default backend, or the original
-        method if the default backend is unavailable.
+    func : 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]):
@@ -199,23 +219,28 @@ def bind_spmd_backend(
     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.
+    If the SPMD backend is unavailable, the method is returned without
+    modification.
 
-    Parameters:
+    Parameters
     ----------
     module_name : str
-        The name of the module where the target function is located (e.g. `covariance`).
+        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.
+        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.
+        If 'True', the method will be decorated without a policy. Default is
+        False.
 
-    Returns:
+    Returns
     -------
-    Callable[..., Any]
-        The decorated method bound to the implementation in SPMD backend, or the original
-        method if the SPMD backend is unavailable.
+    func : 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]):

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/common/hyperparameters.py

@@ -104,6 +104,9 @@ else:
     if daal_check_version((2024, "P", 300)):
         df_infer_hp = backend.decision_forest.infer_hyperparameters
         hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
+    if daal_check_version((2025, "P", 700)):
+        pca_train_hp = backend.decomposition.dim_reduction.train_hyperparameters
+        hyperparameters_backend[("pca", "train")] = pca_train_hp()
     hyperparameters_map = {}
 
     for (algorithm, op), hyperparameters in hyperparameters_backend.items():

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

@@ -18,7 +18,7 @@ import pytest
 
 from onedal import _default_backend as backend
 from onedal.tests.utils._device_selection import get_queues
-from onedal.utils._dpep_helpers import dpctl_available
+from onedal.utils._third_party import dpctl_available
 
 
 @pytest.mark.skipif(

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.7.0.data}/data/Lib/site-packages/onedal/covariance/covariance.py

@@ -58,10 +58,10 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
 
     Parameters
     ----------
-    method : string, default="dense"
+    method : str, default="dense"
         Specifies computation method. Available methods: "dense".
 
-    bias: bool, default=False
+    bias : bool, default=False
         If True biased estimation of covariance is computed which equals to
         the unbiased one multiplied by (n_samples - 1) / n_samples.