scikit-learn-intelex 2024.7.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-2025.0.0.data/data/Lib/site-packages/onedal/_device_offload.py

@@ -0,0 +1,229 @@
+# ==============================================================================
+# 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 logging
+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
+    from dpctl.memory import MemoryUSMDevice, as_usm_memory
+    from dpctl.tensor import usm_ndarray
+
+    dpctl_available = True
+except ImportError:
+    dpctl_available = False
+
+try:
+    import dpnp
+
+    from .utils._array_api import _convert_to_dpnp
+
+    dpnp_available = True
+except ImportError:
+    dpnp_available = False
+
+
+class DummySyclQueue:
+    """This class is designed to act like dpctl.SyclQueue
+    to allow device dispatching in scenarios when dpctl is not available"""
+
+    class DummySyclDevice:
+        def __init__(self, filter_string):
+            self._filter_string = filter_string
+            self.is_cpu = "cpu" in filter_string
+            self.is_gpu = "gpu" in filter_string
+            self.has_aspect_fp64 = self.is_cpu
+
+            if not (self.is_cpu):
+                logging.warning(
+                    "Device support is limited. "
+                    "Please install dpctl for full experience"
+                )
+
+        def get_filter_string(self):
+            return self._filter_string
+
+    def __init__(self, filter_string):
+        self.sycl_device = self.DummySyclDevice(filter_string)
+
+
+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(queue, *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__"
+                )
+            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"][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:
+            raise RuntimeError("Input data shall be located on single target device")
+
+        host_data.append(item)
+    return queue, host_data
+
+
+def _get_global_queue():
+    target = _get_config()["target_offload"]
+
+    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
+
+    if target != "auto":
+        if isinstance(target, QueueClass):
+            return target
+        return QueueClass(target)
+    return None
+
+
+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
+
+        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
+
+    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}

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

@@ -0,0 +1,160 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import numpy as np
+
+from daal4py.sklearn._utils import get_dtype
+
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _check_array
+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.
+    Parameters
+    ----------
+    result_options: string or list, default='all'
+        List of statistics to compute
+
+    Attributes (are existing only if corresponding result option exists)
+    ----------
+        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.
+    """
+
+    def __init__(self, result_options="all"):
+        super().__init__(result_options, algorithm="by_default")
+        self._reset()
+
+    def _reset(self):
+        self._partial_result = self._get_backend(
+            "basic_statistics", None, "partial_compute_result"
+        )
+
+    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`.
+
+        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.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._queue = queue
+        policy = self._get_policy(queue, X)
+        X, weights = _convert_to_supported(policy, X, weights)
+
+        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,
+            )
+
+        if not hasattr(self, "_onedal_params"):
+            dtype = get_dtype(X)
+            self._onedal_params = self._get_onedal_params(False, dtype=dtype)
+
+        X_table, weights_table = to_table(X, weights)
+        self._partial_result = self._get_backend(
+            "basic_statistics",
+            None,
+            "partial_compute",
+            policy,
+            self._onedal_params,
+            self._partial_result,
+            X_table,
+            weights_table,
+        )
+
+    def finalize_fit(self, queue=None):
+        """
+        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.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+        if queue is not None:
+            policy = self._get_policy(queue)
+        else:
+            policy = self._get_policy(self._queue)
+
+        result = self._get_backend(
+            "basic_statistics",
+            None,
+            "finalize_compute",
+            policy,
+            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())
+
+        return self