scikit-learn-intelex 2025.6.1__py310-none-win_amd64.whl → 2025.8.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/__init__.py

@@ -21,9 +21,34 @@ from daal4py.sklearn._utils import daal_check_version
 
 
 class Backend:
-    """Encapsulates the oneDAL pybind11 modules and provides a unified interface to it together with additional properties about dpc/spmd policies"""
 
     def __init__(self, backend_module, is_dpc, is_spmd):
+        """A unified interface to an available oneDAL pybind11 module.
+
+        This class encapsulates a oneDAL pybind11 module allowing for
+        dynamic access of module objects. This simplifies method and
+        attribute access in sklearnex without aliasing in sys.modules.
+        It contains additional attributes for inspection of the pybind11
+        module type (i.e. dpc or spmd) for use in policy creation.
+
+        Parameters
+        ----------
+            backend_module : oneDAL pybind11 module
+                Pybind11 module to be encapsulated.
+
+            is_dpc : bool
+                Flag describing if the module is Data Parallel C++-enabled.
+
+            is_spmd : bool
+                Flag describing if the module is single program, multiple
+                data enabled.
+
+        Returns
+        -------
+            self : Backend
+                Encapsulated oneDAL pybind11 module.
+        """
+
         self.backend = backend_module
         self.is_dpc = is_dpc
         self.is_spmd = is_spmd

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/_config.py

@@ -59,13 +59,14 @@ def _get_onedal_threadlocal_config():
 
 
 def _get_config(copy=True):
-    """Retrieve current values for configuration set
-    by :func:`sklearnex.set_config`
+    """Retrieve current configuration set by :func:`sklearnex.set_config`
+
     Parameters
     ----------
     copy : bool, default=True
-        If False, a mutable view of the configuration is returned. Each thread
-        has a separate copy of the configuration.
+        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.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/_device_offload.py

@@ -16,34 +16,39 @@
 
 import inspect
 import logging
-from collections.abc import Iterable
 from functools import wraps
+from operator import xor
 
 import numpy as np
 from sklearn import get_config
 
 from ._config import _get_config
+from .datatypes import copy_to_dpnp, copy_to_usm, dlpack_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._array_api import _asarray, _get_sycl_namespace, _is_numpy_namespace
+from .utils._third_party import is_dpnp_ndarray
 
 logger = logging.getLogger("sklearnex")
 
 
 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,75 +62,24 @@ 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
+    has_usm_data = None
 
     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,
-            )
-            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)
-            has_host_data = True
-        else:
-            has_host_data = True
-
-        mismatch_host_item = usm_iface is None and item is not None and has_usm_data
-        mismatch_usm_item = usm_iface is not None and has_host_data
-
-        if mismatch_host_item or mismatch_usm_item:
+        if item is None:
+            host_data.append(item)
+            continue
+
+        if usm_iface := hasattr(item, "__sycl_usm_array_interface__"):
+            xp = item.__array_namespace__()
+            item = xp.asnumpy(item)
+            has_usm_data = has_usm_data or has_usm_data is None
+        elif not isinstance(item, np.ndarray) and (hasattr(item, "__dlpack_device__")):
+            item = dlpack_to_numpy(item)
+
+        # set has_usm_data to boolean and use xor to see if they don't match
+        if xor((has_usm_data := bool(has_usm_data)), usm_iface):
             raise RuntimeError("Input data shall be located on single target device")
 
         host_data.append(item)
@@ -140,10 +94,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 +139,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,18 +157,42 @@ 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
 
     return wrapper_impl
+
+
+def support_sycl_format(func):
+    # This wrapper enables scikit-learn functions and methods to work with
+    # all sycl data frameworks as they no longer support numpy implicit
+    # conversion and must be manually converted. This is only necessary
+    # when array API is supported but not active.
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if (
+            not get_config().get("array_api_dispatch", False)
+            and _get_sycl_namespace(*args)[2]
+        ):
+            with QM.manage_global_queue(kwargs.get("queue"), *args):
+                if inspect.isfunction(func) and "." in func.__qualname__:
+                    self, (args, kwargs) = args[0], _get_host_inputs(*args[1:], **kwargs)
+                    return func(self, *args, **kwargs)
+                else:
+                    args, kwargs = _get_host_inputs(*args, **kwargs)
+                    return func(*args, **kwargs)
+        return func(*args, **kwargs)
+
+    return wrapper

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/onedal/basic_statistics/basic_statistics.py

@@ -0,0 +1,151 @@
+# ==============================================================================
+# Copyright 2023 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.
+# ==============================================================================
+
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, to_table
+from ..utils.validation import _is_csr
+
+
+class BasicStatistics:
+    """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"):
+        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 [
+            "min",
+            "max",
+            "sum",
+            "mean",
+            "variance",
+            "variation",
+            "sum_squares",
+            "standard_deviation",
+            "sum_squares_centered",
+            "second_order_raw_moment",
+        ]
+
+    @property
+    def options(self):
+        if self._options == ["all"]:
+            return self.get_all_result_options()
+        return self._options
+
+    @options.setter
+    def options(self, opts):
+        # options always to be an iterable
+        self._options = opts.split("|") if isinstance(opts, str) else opts
+
+    def _get_onedal_params(self, is_csr, dtype=None):
+        return {
+            "fptype": dtype,
+            "method": "sparse" if is_csr else self.algorithm,
+            "result_option": "|".join(self.options),
+        }
+
+    @supports_queue
+    def fit(self, X, sample_weight=None, queue=None):
+        """Generate statistics.
+
+        Parameters
+        ----------
+        X : 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(X)
+
+        is_single_dim = X.ndim == 1
+        X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
+
+        result = self._compute_raw(X_table, sample_weight_table, X_table.dtype, is_csr)
+
+        for opt in self.options:
+            value = from_table(getattr(result, opt), like=X)[0, :]  # 2D table [1, n]
+            setattr(self, opt + "_", value[0] if is_single_dim else value)
+
+        return self
+
+    def _compute_raw(self, data_table, weights_table, dtype=None, is_csr=False):
+        params = self._get_onedal_params(is_csr, dtype)
+        return self.compute(params, data_table, weights_table)

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

@@ -13,30 +13,27 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
+from .basic_statistics import BasicStatistics
 
-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._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array
-from .basic_statistics import BaseBasicStatistics
+class IncrementalBasicStatistics(BasicStatistics):
+    """Incremental oneDAL low order moments estimator.
 
+    Calculate basic statistics for data split into batches.
 
-class IncrementalBasicStatistics(BaseBasicStatistics):
-    """
-    Incremental estimator for basic statistics based on oneDAL implementation.
-    Allows to compute basic statistics if data are splitted 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.
+
+    algorithm : str, default=str('by_default')
+        Method for statistics computation.
 
-    Attributes (are existing only if corresponding result option exists)
+    Attributes
     ----------
         min : ndarray of shape (n_features,)
             Minimum of each feature over all samples.
@@ -67,10 +64,14 @@ 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"):
-        super().__init__(result_options, algorithm="by_default")
+    def __init__(self, result_options="all", algorithm="by_default"):
+        super().__init__(result_options, algorithm)
         self._reset()
         self._queue = None
 
@@ -85,6 +86,7 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
 
     def _reset(self):
         self._need_to_finalize = False
+        self._outtype = None
         self._queue = None
         # get the _partial_result pointer from backend
         self._partial_result = self.partial_compute_result()
@@ -100,10 +102,8 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
         return data
 
     @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`.
+    def partial_fit(self, X, sample_weight=None, queue=None):
+        """Generate partial statistics from batch data in `_partial_result`.
 
         Parameters
         ----------
@@ -111,56 +111,37 @@ 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.
+        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.
         """
-        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
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
 
-        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,
-                )
+        X_table, sample_weight_table = to_table(X, sample_weight, queue=queue)
 
         if not hasattr(self, "_onedal_params"):
-            dtype = get_dtype(X)
-            self._onedal_params = self._get_onedal_params(False, dtype=dtype)
+            self._onedal_params = self._get_onedal_params(False, dtype=X.dtype)
 
-        X_table, weights_table = to_table(X, weights, queue=queue)
         self._partial_result = self.partial_compute(
-            self._onedal_params, self._partial_result, X_table, weights_table
+            self._onedal_params, self._partial_result, X_table, sample_weight_table
         )
 
         self._need_to_finalize = True
         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
         -------
@@ -171,10 +152,14 @@ class IncrementalBasicStatistics(BaseBasicStatistics):
             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())
+            for opt in self.options:
+                setattr(
+                    self,
+                    opt + "_",
+                    from_table(getattr(result, opt), like=self._outtype)[0, :],
+                )
 
+            self._outtype = None
             self._need_to_finalize = False
 
         return self

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/basic_statistics/tests/test_basic_statistics.py

@@ -19,7 +19,6 @@ import pytest
 from numpy.testing import assert_allclose
 from scipy import sparse as sp
 
-from daal4py.sklearn._utils import daal_check_version
 from onedal.basic_statistics import BasicStatistics
 from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._device_selection import get_queues
@@ -57,7 +56,7 @@ def test_single_option_on_random_data(
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr = function(weighted_data)
@@ -89,7 +88,7 @@ def test_multiple_options_on_random_data(queue, row_count, column_count, weighte
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    res_mean, res_max, res_sum = result.mean_, result.max_, result.sum_
     if weighted:
         weighted_data = np.diag(weights) @ data
         gtr_mean, gtr_max, gtr_sum = (
@@ -136,7 +135,7 @@ def test_all_option_on_random_data(queue, row_count, column_count, weighted, dty
     for result_option in options_and_tests:
         function, tols = options_and_tests[result_option]
         fp32tol, fp64tol = tols
-        res = getattr(result, result_option)
+        res = getattr(result, result_option + "_")
         if weighted:
             gtr = function(weighted_data)
         else:
@@ -168,7 +167,7 @@ def test_1d_input_on_random_data(queue, result_option, data_size, weighted, dtyp
 
     result = basicstat.fit(data, sample_weight=weights, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     if weighted:
         weighted_data = weights * data
         gtr = function(weighted_data)
@@ -199,7 +198,7 @@ def test_basic_csr(queue, dtype):
     basicstat = BasicStatistics(result_options="mean")
     result = basicstat.fit(data, queue=queue)
 
-    res_mean = result.mean
+    res_mean = result.mean_
     gtr_mean = data.mean(axis=0)
     tol = 5e-6 if res_mean.dtype == np.float32 else 1e-9
     assert_allclose(gtr_mean, res_mean, rtol=tol)
@@ -232,7 +231,7 @@ def test_options_csr(queue, option, dtype):
     basicstat = BasicStatistics(result_options=result_option)
     result = basicstat.fit(data, queue=queue)
 
-    res = getattr(result, result_option)
+    res = getattr(result, result_option + "_")
     func = getattr(data, function)
     gtr = func(axis=0)
     if type(gtr).__name__ != "ndarray":