scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

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

@@ -0,0 +1,151 @@
+# ==============================================================================
+# 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:
+
+    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
+
+    # 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",
+    "dummy",
+    "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.10.0.data/data/Lib/site-packages/onedal/_config.py

@@ -0,0 +1,80 @@
+# ==============================================================================
+# 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 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()
+
+
+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 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.
+
+    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-2025.10.0.data/data/Lib/site-packages/onedal/_device_offload.py

@@ -0,0 +1,199 @@
+# ==============================================================================
+# 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 inspect
+import logging
+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, _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 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)
+    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
+
+
+def _transfer_to_host(*data):
+    has_usm_data = None
+
+    host_data = []
+    for item in data:
+        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)
+    return has_usm_data, host_data
+
+
+def _get_host_inputs(*args, **kwargs):
+    _, hostargs = _transfer_to_host(*args)
+    _, hostvalues = _transfer_to_host(*kwargs.values())
+    hostkwargs = dict(zip(kwargs.keys(), hostvalues))
+    return hostargs, hostkwargs
+
+
+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):
+        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
+
+        # 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"
+            and _get_config()["use_raw_input"] is True
+        )
+        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:
+                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())[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)
+            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)
+
+            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, "__array_namespace__", lambda: None)()
+            if input_array_api and not _is_numpy_namespace(input_array_api):
+                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.10.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)