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

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

@@ -1,83 +1,125 @@
-# ==============================================================================
-# Copyright 2021 Intel Corporation
-# Copyright 2024 Fujitsu Limited
-#
-# 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 platform
-
-from daal4py.sklearn._utils import daal_check_version
-
-if "Windows" in platform.system():
-    import os
-    import site
-    import sys
-
-    arch_dir = platform.machine()
-    plt_dict = {"x86_64": "intel64", "AMD64": "intel64", "aarch64": "arm"}
-    arch_dir = plt_dict[arch_dir] if arch_dir in plt_dict else arch_dir
-    path_to_env = site.getsitepackages()[0]
-    path_to_libs = os.path.join(path_to_env, "Library", "bin")
-    if sys.version_info.minor >= 8:
-        if "DALROOT" in os.environ:
-            dal_root_redist = os.path.join(os.environ["DALROOT"], "redist", arch_dir)
-            if os.path.exists(dal_root_redist):
-                os.add_dll_directory(dal_root_redist)
-        try:
-            os.add_dll_directory(path_to_libs)
-        except FileNotFoundError:
-            pass
-    os.environ["PATH"] = path_to_libs + os.pathsep + os.environ["PATH"]
-
-try:
-    import onedal._onedal_py_dpc as _backend
-
-    _is_dpc_backend = True
-except ImportError:
-    import onedal._onedal_py_host as _backend
-
-    _is_dpc_backend = False
-
-_is_spmd_backend = False
-
-if _is_dpc_backend:
-    try:
-        import onedal._onedal_py_spmd_dpc as _spmd_backend
-
-        _is_spmd_backend = True
-    except ImportError:
-        _is_spmd_backend = False
-
-
-__all__ = ["covariance", "decomposition", "ensemble", "neighbors", "primitives", "svm"]
-
-if _is_spmd_backend:
-    __all__.append("spmd")
-
-if daal_check_version((2023, "P", 100)):
-    __all__ += ["basic_statistics", "linear_model"]
-
-    if _is_spmd_backend:
-        __all__ += [
-            "spmd.basic_statistics",
-            "spmd.decomposition",
-            "spmd.linear_model",
-            "spmd.neighbors",
-        ]
-
-if daal_check_version((2023, "P", 200)):
-    __all__ += ["cluster"]
-
-    if _is_spmd_backend:
-        __all__ += ["spmd.cluster"]
+# ==============================================================================
+# Copyright 2021 Intel Corporation
+# Copyright 2024 Fujitsu Limited
+#
+# 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 platform
+
+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):
+        self.backend = backend_module
+        self.is_dpc = is_dpc
+        self.is_spmd = is_spmd
+
+    # accessing the instance will return the backend_module
+    def __getattr__(self, name):
+        return getattr(self.backend, name)
+
+    def __repr__(self) -> str:
+        return f"Backend({self.backend}, is_dpc={self.is_dpc}, is_spmd={self.is_spmd})"
+
+
+if "Windows" in platform.system():
+    import os
+    import site
+    import sys
+
+    arch_dir = platform.machine()
+    plt_dict = {"x86_64": "intel64", "AMD64": "intel64", "aarch64": "arm"}
+    arch_dir = plt_dict[arch_dir] if arch_dir in plt_dict else arch_dir
+    path_to_env = site.getsitepackages()[0]
+    path_to_libs = os.path.join(path_to_env, "Library", "bin")
+    if sys.version_info.minor >= 8:
+        if "DALROOT" in os.environ:
+            dal_root_redist = os.path.join(os.environ["DALROOT"], "redist", arch_dir)
+            if os.path.exists(dal_root_redist):
+                os.add_dll_directory(dal_root_redist)
+        try:
+            os.add_dll_directory(path_to_libs)
+        except FileNotFoundError:
+            pass
+    os.environ["PATH"] = path_to_libs + os.pathsep + os.environ["PATH"]
+
+
+try:
+    # use dpc backend if available
+    import onedal._onedal_py_dpc
+
+    _dpc_backend = Backend(onedal._onedal_py_dpc, is_dpc=True, is_spmd=False)
+
+    _host_backend = None
+except ImportError:
+    # fall back to host backend
+    _dpc_backend = None
+
+    import onedal._onedal_py_host
+
+    _host_backend = Backend(onedal._onedal_py_host, is_dpc=False, is_spmd=False)
+
+try:
+    # also load spmd backend if available
+    import onedal._onedal_py_spmd_dpc
+
+    _spmd_backend = Backend(onedal._onedal_py_spmd_dpc, is_dpc=True, is_spmd=True)
+except ImportError:
+    _spmd_backend = None
+
+# if/elif/else layout required for pylint to realize _default_backend cannot be None
+if _dpc_backend is not None:
+    _default_backend = _dpc_backend
+elif _host_backend is not None:
+    _default_backend = _host_backend
+else:
+    raise ImportError("No oneDAL backend available")
+
+# Core modules to export
+__all__ = [
+    "_host_backend",
+    "_default_backend",
+    "_dpc_backend",
+    "_spmd_backend",
+    "covariance",
+    "decomposition",
+    "ensemble",
+    "neighbors",
+    "primitives",
+    "svm",
+]
+
+# Additional features based on version checks
+if daal_check_version((2023, "P", 100)):
+    __all__ += ["basic_statistics", "linear_model"]
+if daal_check_version((2023, "P", 200)):
+    __all__ += ["cluster"]
+
+# Exports if SPMD backend is available
+if _spmd_backend is not None:
+    __all__ += ["spmd"]
+    if daal_check_version((2023, "P", 100)):
+        __all__ += [
+            "spmd.basic_statistics",
+            "spmd.decomposition",
+            "spmd.linear_model",
+            "spmd.neighbors",
+        ]
+    if daal_check_version((2023, "P", 200)):
+        __all__ += ["spmd.cluster"]
+
+__version__ = "2021.6"

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

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

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

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

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

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