scikit-learn-intelex 2024.6.0__py39-none-win_amd64.whl → 2025.0.0__py39-none-win_amd64.whl

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/__init__.py

@@ -0,0 +1,83 @@
+# ==============================================================================
+# 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"]

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/_config.py

@@ -0,0 +1,53 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+"""Tools to expose some sklearnex's config settings to onedal4py level."""
+
+import threading
+
+_default_global_config = {
+    "target_offload": "auto",
+    "allow_fallback_to_host": False,
+}
+
+_threadlocal = threading.local()
+
+
+def _get_onedal_threadlocal_config():
+    if not hasattr(_threadlocal, "global_config"):
+        _threadlocal.global_config = _default_global_config.copy()
+    return _threadlocal.global_config
+
+
+def _get_config(copy=True):
+    """Retrieve current values for configuration set
+    by :func:`sklearnex.set_config`
+    Parameters
+    ----------
+    copy : bool, default=True
+        If False, the values ​​of the global config are returned,
+        which can further be overwritten.
+    Returns
+    -------
+    config : dict
+        Keys are parameter names `target_offload` and
+        `allow_fallback_to_host` that can be passed
+        to :func:`sklearnex.set_config`.
+    """
+    onedal_config = _get_onedal_threadlocal_config()
+    if copy:
+        onedal_config = onedal_config.copy()
+    return onedal_config

{scikit_learn_intelex-2024.6.0.data/data/Lib/site-packages/sklearnex → scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal}/_device_offload.py

@@ -1,5 +1,5 @@
 # ==============================================================================
-# Copyright 2021 Intel Corporation
+# 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.
@@ -15,11 +15,14 @@
 # ==============================================================================
 
 import logging
-import sys
 from collections.abc import Iterable
 from functools import wraps
 
 import numpy as np
+from sklearn import get_config
+
+from ._config import _get_config
+from .utils._array_api import _asarray, _is_numpy_namespace
 
 try:
     from dpctl import SyclQueue
@@ -33,17 +36,12 @@ except ImportError:
 try:
     import dpnp
 
+    from .utils._array_api import _convert_to_dpnp
+
     dpnp_available = True
 except ImportError:
     dpnp_available = False
 
-from ._config import get_config
-from ._utils import get_patch_message
-
-oneapi_is_available = "daal4py.oneapi" in sys.modules
-if oneapi_is_available:
-    from daal4py.oneapi import _get_device_name_sycl_ctxt, _get_sycl_ctxt_params
-
 
 class DummySyclQueue:
     """This class is designed to act like dpctl.SyclQueue
@@ -54,8 +52,6 @@ class DummySyclQueue:
             self._filter_string = filter_string
             self.is_cpu = "cpu" in filter_string
             self.is_gpu = "gpu" in filter_string
-            # TODO: check for possibility of fp64 support
-            # on other devices in this dummy class
             self.has_aspect_fp64 = self.is_cpu
 
             if not (self.is_cpu):
@@ -71,39 +67,29 @@ class DummySyclQueue:
         self.sycl_device = self.DummySyclDevice(filter_string)
 
 
-def _get_device_info_from_daal4py():
-    if oneapi_is_available:
-        return _get_device_name_sycl_ctxt(), _get_sycl_ctxt_params()
-    return None, dict()
-
-
-def _get_global_queue():
-    target = get_config()["target_offload"]
-    d4p_target, _ = _get_device_info_from_daal4py()
-    if d4p_target == "host":
-        d4p_target = "cpu"
+def _copy_to_usm(queue, array):
+    if not dpctl_available:
+        raise RuntimeError(
+            "dpctl need to be installed to work " "with __sycl_usm_array_interface__"
+        )
 
-    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
+    if hasattr(array, "__array__"):
 
-    if target != "auto":
-        if d4p_target is not None and d4p_target != target:
-            if not isinstance(target, str):
-                if d4p_target not in target.sycl_device.get_filter_string():
-                    raise RuntimeError(
-                        "Cannot use target offload option "
-                        "inside daal4py.oneapi.sycl_context"
-                    )
-            else:
-                raise RuntimeError(
-                    "Cannot use target offload option "
-                    "inside daal4py.oneapi.sycl_context"
-                )
-        if isinstance(target, QueueClass):
-            return target
-        return QueueClass(target)
-    if d4p_target is not None:
-        return QueueClass(d4p_target)
-    return None
+        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(queue, *data):
@@ -112,6 +98,7 @@ def _transfer_to_host(queue, *data):
     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(
@@ -138,6 +125,11 @@ def _transfer_to_host(queue, *data):
                 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
 
@@ -151,107 +143,87 @@ def _transfer_to_host(queue, *data):
     return queue, host_data
 
 
-def _get_backend(obj, queue, method_name, *data):
-    cpu_device = queue is None or queue.sycl_device.is_cpu
-    gpu_device = queue is not None and queue.sycl_device.is_gpu
-
-    if cpu_device:
-        patching_status = obj._onedal_cpu_supported(method_name, *data)
-        if patching_status.get_status():
-            return "onedal", queue, patching_status
-        else:
-            return "sklearn", None, patching_status
-
-    _, d4p_options = _get_device_info_from_daal4py()
-    allow_fallback_to_host = get_config()["allow_fallback_to_host"] or d4p_options.get(
-        "host_offload_on_fail", False
-    )
+def _get_global_queue():
+    target = _get_config()["target_offload"]
 
-    if gpu_device:
-        patching_status = obj._onedal_gpu_supported(method_name, *data)
-        if patching_status.get_status():
-            return "onedal", queue, patching_status
-        else:
-            if allow_fallback_to_host:
-                patching_status = obj._onedal_cpu_supported(method_name, *data)
-                if patching_status.get_status():
-                    return "onedal", None, patching_status
-                else:
-                    return "sklearn", None, patching_status
-            else:
-                return "sklearn", None, patching_status
+    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
 
-    raise RuntimeError("Device support is not implemented")
+    if target != "auto":
+        if isinstance(target, QueueClass):
+            return target
+        return QueueClass(target)
+    return None
 
 
-def dispatch(obj, method_name, branches, *args, **kwargs):
+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())
     hostkwargs = dict(zip(kwargs.keys(), hostvalues))
+    return q, 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):
+    """
+    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
+
+    Notes
+    -----
+    Queue will not be changed if provided explicitly.
+    """
+
+    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 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
 
-    backend, q, patching_status = _get_backend(obj, q, method_name, *hostargs)
-
-    if backend == "onedal":
-        patching_status.write_log(queue=q)
-        return branches[backend](obj, *hostargs, **hostkwargs, queue=q)
-    if backend == "sklearn":
-        patching_status.write_log()
-        return branches[backend](obj, *hostargs, **hostkwargs)
-    raise RuntimeError(
-        f"Undefined backend {backend} in " f"{obj.__class__.__name__}.{method_name}"
-    )
-
-
-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
-
+        if freefunc:
 
-if dpnp_available:
+            @wraps(func)
+            def wrapper_free(*args, **kwargs):
+                return wrapper_impl(None, *args, **kwargs)
 
-    def _convert_to_dpnp(array):
-        if isinstance(array, usm_ndarray):
-            return dpnp.array(array, copy=False)
-        elif isinstance(array, Iterable):
-            for i in range(len(array)):
-                array[i] = _convert_to_dpnp(array[i])
-        return array
+            return wrapper_free
 
+        @wraps(func)
+        def wrapper_with_self(self, *args, **kwargs):
+            return wrapper_impl(self, *args, **kwargs)
 
-def wrap_output_data(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        data = (*args, *kwargs.values())
-        if len(data) == 0:
-            usm_iface = None
-        else:
-            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
-        result = func(self, *args, **kwargs)
-        if usm_iface is not None:
-            result = _copy_to_usm(usm_iface["syclobj"], result)
-            if dpnp_available and isinstance(data[0], dpnp.ndarray):
-                result = _convert_to_dpnp(result)
-        return result
+        return wrapper_with_self
 
-    return wrapper
+    return decorator

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

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import warnings
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+
+from ..common._base import BaseEstimator
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _is_csr
+from ..utils.validation import _check_array
+
+
+class BaseBasicStatistics(BaseEstimator, metaclass=ABCMeta):
+    @abstractmethod
+    def __init__(self, result_options, algorithm):
+        self.options = result_options
+        self.algorithm = algorithm
+
+    @staticmethod
+    def get_all_result_options():
+        return [
+            "min",
+            "max",
+            "sum",
+            "mean",
+            "variance",
+            "variation",
+            "sum_squares",
+            "standard_deviation",
+            "sum_squares_centered",
+            "second_order_raw_moment",
+        ]
+
+    def _get_result_options(self, options):
+        if options == "all":
+            options = self.get_all_result_options()
+        if isinstance(options, list):
+            options = "|".join(options)
+        assert isinstance(options, str)
+        return options
+
+    def _get_onedal_params(self, is_csr, dtype=np.float32):
+        options = self._get_result_options(self.options)
+        return {
+            "fptype": "float" if dtype == np.float32 else "double",
+            "method": "sparse" if is_csr else self.algorithm,
+            "result_option": options,
+        }
+
+
+class BasicStatistics(BaseBasicStatistics):
+    """
+    Basic Statistics oneDAL implementation.
+    """
+
+    def __init__(self, result_options="all", algorithm="by_default"):
+        super().__init__(result_options, algorithm)
+
+    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)
+
+        data, sample_weight = _convert_to_supported(policy, data, sample_weight)
+        is_single_dim = data.ndim == 1
+        data_table, weights_table = to_table(data, sample_weight)
+
+        dtype = data.dtype
+        raw_result = self._compute_raw(data_table, weights_table, policy, dtype, is_csr)
+        for opt, raw_value in raw_result.items():
+            value = from_table(raw_value).ravel()
+            if is_single_dim:
+                setattr(self, opt, value[0])
+            else:
+                setattr(self, opt, value)
+
+        return self
+
+    def _compute_raw(
+        self, data_table, weights_table, policy, dtype=np.float32, is_csr=False
+    ):
+        module = self._get_backend("basic_statistics")
+        params = self._get_onedal_params(is_csr, dtype)
+        result = module.compute(policy, params, data_table, weights_table)
+        options = self._get_result_options(self.options).split("|")
+
+        return {opt: getattr(result, opt) for opt in options}