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/common/_backend.py

@@ -0,0 +1,258 @@
+# ==============================================================================
+# 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 logging
+from typing import Any, Callable, Literal, Optional
+
+from onedal import Backend, _default_backend, _spmd_backend
+from onedal.utils import _sycl_queue_manager as QM
+
+logger = logging.getLogger("sklearnex")
+
+# define types for backend functions: default, dpc, spmd
+BackendType = Literal["none", "host", "dpc", "spmd"]
+
+
+class BackendManager:
+    def __init__(self, backend_module):
+        self.backend = backend_module
+
+    def get_backend_type(self) -> BackendType:
+        if self.backend is None:
+            return "none"
+        if self.backend.is_spmd:
+            return "spmd"
+        if self.backend.is_dpc:
+            return "dpc"
+        return "host"
+
+    def get_backend_component(self, module_name: str, component_name: str):
+        """Get a component of the backend module.
+
+        Parameters
+        ----------
+            module_name : str
+                The module to get the component from.
+
+            component_name : str
+                The component to get from the module.
+
+        Returns
+        -------
+            result : method, attribute or module
+                The component of the module.
+        """
+        submodules = module_name.split(".")
+        module = getattr(self.backend, submodules[0])
+        for submodule in submodules[1:]:
+            module = getattr(module, submodule)
+
+        # component can be provided like submodule.method, there can be arbitrary number of submodules
+        # and methods
+        result = module
+        for part in component_name.split("."):
+            result = getattr(result, part)
+
+        return result
+
+
+default_manager = BackendManager(_default_backend)
+spmd_manager = BackendManager(_spmd_backend)
+
+
+class BackendFunction:
+    """Wrapper around backend function to allow setting auxiliary information.
+
+    Parameters
+    ----------
+    method : callable
+        Pybind11 backend function.
+
+    backend : Backend
+        Encapsulated oneDAL pybind11 interface.
+
+    name : str
+        Name of function.
+
+    no_policy : bool
+       Flag that a oneDAL policy is not required for function evaluation.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., Any],
+        backend: Backend,
+        name: str,
+        no_policy: bool,
+    ):
+        self.method = method
+        self.name = name
+        self.backend = backend
+        self.no_policy = no_policy
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Dispatch to backend function with the appropriate policy which is determined from the global queue"""
+        if not args and not kwargs:
+            # immediate dispatching without any arguments, in particular no policy
+            return self.method()
+
+        if self.no_policy:
+            return self.method(*args, **kwargs)
+
+        # use globally configured queue (from `target_offload` configuration or provided data)
+        queue = QM.get_global_queue()
+
+        if queue is not None and not (self.backend.is_dpc or self.backend.is_spmd):
+            raise RuntimeError("Operations using queues require the DPC/SPMD backend")
+
+        if self.backend.is_spmd and queue is None:
+            raise RuntimeError("Executing functions from SPMD backend requires a queue")
+
+        # craft the correct policy including the device queue
+        policy = self.backend.get_policy(queue)
+
+        logger.debug(
+            f"Dispatching function '{self.name}' with policy {policy} to {self.backend}"
+        )
+
+        # dispatch to backend function
+        return self.method(policy, *args, **kwargs)
+
+    def __repr__(self) -> str:
+        return f"BackendFunction({self.backend}.{self.name})"
+
+
+def __decorator(
+    method: Callable[..., Any],
+    backend_manager: BackendManager,
+    module_name: str,
+    lookup_name: Optional[str],
+    no_policy: bool,
+) -> Callable[..., Any]:
+    """Decorator to bind a method to the specified backend."""
+    if lookup_name is None:
+        lookup_name = method.__name__
+
+    if backend_manager.get_backend_type() == "none":
+        raise RuntimeError("Internal __decorator() should not be called with no backend")
+
+    backend_method = backend_manager.get_backend_component(module_name, lookup_name)
+    wrapped_method = BackendFunction(
+        backend_method,
+        backend_manager.backend,
+        name=f"{module_name}.{method.__name__}",
+        no_policy=no_policy,
+    )
+
+    backend_type = backend_manager.get_backend_type()
+    logger.debug(
+        f"Assigned method '<{backend_type}_backend>.{module_name}.{lookup_name}' to '{method.__qualname__}'"
+    )
+
+    return wrapped_method
+
+
+def bind_default_backend(
+    module_name: str, lookup_name: Optional[str] = None, no_policy=False
+):
+    """
+    Decorator to bind a method from the default backend to a class.
+
+    This decorator binds a method implementation from the default backend
+    (host/dpc). If the default backend is unavailable, the method is
+    returned without modification.
+
+    Parameters
+    ----------
+    module_name : str
+        The name of the module where the target function is located (e.g.
+        `covariance`).
+
+    lookup_name : Optional[str], optional
+        The name of the method to look up in the backend module. If not
+        provided, the name of the decorated method is used.
+
+    no_policy : bool, optional
+        If 'True', the method will be decorated without a policy. Default is
+        False.
+
+    Returns
+    -------
+    func : Callable[..., Any]
+        The decorated method bound to the implementation in default
+        backend, or the original method if the default backend is
+        unavailable.
+    """
+
+    def decorator(method: Callable[..., Any]):
+        # grab the lookup_name from outer scope
+        nonlocal lookup_name
+
+        if _default_backend is None:
+            logger.debug(
+                f"Default backend unavailable, skipping decoration for '{method.__name__}'"
+            )
+            return method
+
+        return __decorator(method, default_manager, module_name, lookup_name, no_policy)
+
+    return decorator
+
+
+def bind_spmd_backend(
+    module_name: str, lookup_name: Optional[str] = None, no_policy=False
+):
+    """
+    Decorator to bind a method from the SPMD backend to a class.
+
+    This decorator binds a method implementation from the SPMD backend.
+    If the SPMD backend is unavailable, the method is returned without
+    modification.
+
+    Parameters
+    ----------
+    module_name : str
+        The name of the module where the target function is located (e.g.
+        `covariance`).
+
+    lookup_name : Optional[str], optional
+        The name of the method to look up in the backend module. If not
+        provided, the name of the decorated method is used.
+
+    no_policy : bool, optional
+        If 'True', the method will be decorated without a policy. Default is
+        False.
+
+    Returns
+    -------
+    func : Callable[..., Any]
+        The decorated method bound to the implementation in SPMD backend,
+        or the original method if the SPMD backend is unavailable.
+    """
+
+    def decorator(method: Callable[..., Any]):
+        # grab the lookup_name from outer scope
+        nonlocal lookup_name
+
+        if _spmd_backend is None:
+            logger.debug(
+                f"SPMD backend unavailable, skipping decoration for '{method.__name__}'"
+            )
+            return method
+
+        return __decorator(method, spmd_manager, module_name, lookup_name, no_policy)
+
+    return decorator

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/common/_estimator_checks.py

@@ -0,0 +1,47 @@
+# ===============================================================================
+# Copyright 2022 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.
+# ===============================================================================
+
+
+def _check_is_fitted(estimator, attributes=None, *, msg=None):
+    if msg is None:
+        msg = (
+            "This %(name)s instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using this estimator."
+        )
+
+    if not (
+        hasattr(estimator, "fit")
+        or (hasattr(estimator, "partial_fit") and hasattr(estimator, "finalize_fit"))
+    ):
+        raise TypeError("%s is not an estimator instance." % (estimator))
+
+    if attributes is not None:
+        if not isinstance(attributes, (list, tuple)):
+            attributes = [attributes]
+        attrs = all([hasattr(estimator, attr) for attr in attributes])
+    else:
+        attrs = [v for v in vars(estimator) if v.endswith("_") and not v.startswith("__")]
+
+    if not attrs:
+        raise AttributeError(msg % {"name": type(estimator).__name__})
+
+
+def _is_classifier(estimator):
+    return getattr(estimator, "_estimator_type", None) == "classifier"
+
+
+def _is_regressor(estimator):
+    return getattr(estimator, "_estimator_type", None) == "regressor"

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/common/_mixin.py

@@ -0,0 +1,62 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+
+class ClusterMixin:
+    _estimator_type = "clusterer"
+
+    def fit_predict(self, X, y=None, queue=None, **kwargs):
+        self.fit(X, queue=queue, **kwargs)
+        return self.labels_
+
+    def _more_tags(self):
+        return {"preserves_dtype": []}
+
+
+class ClassifierMixin:
+    _estimator_type = "classifier"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import accuracy_score
+
+        return accuracy_score(
+            y, self.predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class RegressorMixin:
+    _estimator_type = "regressor"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import r2_score
+
+        return r2_score(y, self.predict(X, queue=queue), sample_weight=sample_weight)
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class TransformerMixin:
+    _estimator_type = "transformer"
+
+    def fit_transform(self, X, y=None, queue=None, **fit_params):
+        if y is None:
+            return self.fit(X, queue=queue, **fit_params).transform(X, queue=queue)
+        else:
+            return self.fit(X, y, queue=queue, **fit_params).transform(X, queue=queue)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/common/hyperparameters.py

@@ -0,0 +1,148 @@
+# ==============================================================================
+# 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 typing import Callable, Dict, Tuple
+from warnings import warn
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal import _default_backend as backend
+
+if not daal_check_version((2024, "P", 0)):
+    warn("Hyperparameters are supported in oneDAL starting from 2024.0.0 version.")
+    hyperparameters_map = {}
+else:
+    _hparams_reserved_words = [
+        "algorithm",
+        "op",
+        "setters",
+        "getters",
+        "backend",
+        "is_default",
+        "to_dict",
+    ]
+
+    class HyperParameters:
+        """Class for simplified interaction with oneDAL hyperparameters.
+        Overrides `__getattribute__` and `__setattr__` to utilize getters and setters
+        of hyperparameter class from onedal backend.
+        """
+
+        def __init__(self, algorithm, op, setters, getters, backend):
+            self.algorithm = algorithm
+            self.op = op
+            self.setters = setters
+            self.getters = getters
+            self.backend = backend
+            self.is_default = True
+
+        def __getattribute__(self, __name):
+            if __name in _hparams_reserved_words:
+                if __name == "backend":
+                    # `backend` attribute accessed only for oneDAL kernel calls
+                    logging.getLogger("sklearnex").debug(
+                        "Using next hyperparameters for "
+                        f"'{self.algorithm}.{self.op}': {self.to_dict()}"
+                    )
+                return super().__getattribute__(__name)
+            elif __name in self.getters.keys():
+                return self.getters[__name]()
+            try:
+                # try to return attribute from base class
+                # required to read builtin attributes like __class__, __doc__, etc.
+                # which are used in debuggers
+                return super().__getattribute__(__name)
+            except AttributeError:
+                # raise an AttributeError with a hyperparameter-specific message
+                # for easier debugging
+                raise AttributeError(
+                    f"Unknown attribute '{__name}' in "
+                    f"'{self.algorithm}.{self.op}' hyperparameters"
+                )
+
+        def __setattr__(self, __name, __value):
+            if __name in _hparams_reserved_words:
+                super().__setattr__(__name, __value)
+            elif __name in self.setters.keys():
+                self.is_default = False
+                self.setters[__name](__value)
+            else:
+                raise ValueError(
+                    f"Unknown attribute '{__name}' in "
+                    f"'{self.algorithm}.{self.op}' hyperparameters"
+                )
+
+        def to_dict(self):
+            return {name: getter() for name, getter in self.getters.items()}
+
+    def get_methods_with_prefix(obj, prefix):
+        return {
+            method.replace(prefix, ""): getattr(obj, method)
+            for method in filter(lambda f: f.startswith(prefix), dir(obj))
+        }
+
+    hyperparameters_backend: Dict[Tuple[str, str], Callable] = {
+        (
+            "linear_regression",
+            "train",
+        ): lambda: backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): lambda: backend.covariance.compute_hyperparameters(),
+    }
+    if daal_check_version((2024, "P", 300)):
+        hyperparameters_backend[("decision_forest", "infer")] = (
+            lambda: backend.decision_forest.infer_hyperparameters()
+        )
+    if daal_check_version((2025, "P", 700)):
+        hyperparameters_backend[("pca", "train")] = (
+            lambda: backend.decomposition.dim_reduction.train_hyperparameters()
+        )
+
+    hyperparameters_map: Dict[Tuple[str, str], HyperParameters] = {}
+
+    for (algorithm, op), hyperparameters_lambda in hyperparameters_backend.items():
+        hyperparameters = hyperparameters_lambda()
+        setters = get_methods_with_prefix(hyperparameters, "set_")
+        getters = get_methods_with_prefix(hyperparameters, "get_")
+
+        if set(setters.keys()) != set(getters.keys()):
+            raise ValueError(
+                f"Setters and getters in '{algorithm}.{op}' "
+                "hyperparameters wrapper do not correspond."
+            )
+
+        hyperparameters_map[(algorithm, op)] = HyperParameters(
+            algorithm, op, setters, getters, hyperparameters
+        )
+
+    def get_hyperparameters_backend(algorithm, op):
+        """Get hyperparameters for a specific algorithm and operation."""
+        if (algorithm, op) in hyperparameters_backend:
+            return hyperparameters_backend[(algorithm, op)]()
+        else:
+            raise ValueError(f"Hyperparameters for '{algorithm}.{op}' are not defined.")
+
+
+def get_hyperparameters(algorithm: str, op: str) -> HyperParameters:
+    return hyperparameters_map.get((algorithm, op), None)
+
+
+def reset_hyperparameters(algorithm: str, op: str) -> None:
+    new_hyperparameters_backend = get_hyperparameters_backend(algorithm, op)
+    new_setters = get_methods_with_prefix(new_hyperparameters_backend, "set_")
+    new_getters = get_methods_with_prefix(new_hyperparameters_backend, "get_")
+    hyperparameters_map[(algorithm, op)] = HyperParameters(
+        algorithm, op, new_setters, new_getters, new_hyperparameters_backend
+    )

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -0,0 +1,148 @@
+# ==============================================================================
+# 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 pytest
+
+from onedal import _default_backend as backend
+from onedal.tests.utils._device_selection import get_queues
+from onedal.utils._third_party import dpctl_available
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("device_type", ["cpu", "gpu"])
+@pytest.mark.parametrize("device_number", [None, 0, 1, 2, 3])
+def test_sycl_queue_string_creation(device_type, device_number):
+    # create devices from strings
+    from dpctl import SyclQueue
+    from dpctl._sycl_queue import SyclQueueCreationError
+
+    onedal_SyclQueue = backend.SyclQueue
+
+    device = (
+        ":".join([device_type, str(device_number)])
+        if device_number is not None
+        else device_type
+    )
+
+    raised_exception_dpctl = False
+    raised_exception_backend = False
+
+    try:
+        dpctl_string = SyclQueue(device).sycl_device.filter_string
+    except SyclQueueCreationError:
+        raised_exception_dpctl = True
+
+    try:
+        onedal_string = onedal_SyclQueue(device).sycl_device.filter_string
+    except RuntimeError:
+        raised_exception_backend = True
+
+    assert raised_exception_dpctl == raised_exception_backend
+    if not raised_exception_backend:
+        # dpctl filter string converts simple sycl filter_strings
+        # i.e. "gpu:1" -> "opencl:gpu:0", use SyclQueue to convert
+        # for matching, as oneDAL sycl queue only returns simple
+        # strings as these are operationally sufficient
+        assert SyclQueue(onedal_string).sycl_device.filter_string == dpctl_string
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_queue_conversion(queue):
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    SyclQueue = queue.__class__
+    onedal_SyclQueue = backend.SyclQueue
+
+    q = onedal_SyclQueue(queue)
+
+    # convert back and forth to test `_get_capsule` attribute
+    for i in range(10):
+        q = SyclQueue(q.sycl_device.filter_string)
+        q = onedal_SyclQueue(q)
+
+    assert q.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_device_attributes(queue):
+    from dpctl import SyclQueue
+
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    onedal_SyclQueue = backend.SyclQueue
+
+    onedal_queue = onedal_SyclQueue(queue)
+
+    # check fp64 support
+    assert onedal_queue.sycl_device.has_aspect_fp64 == queue.sycl_device.has_aspect_fp64
+    # check fp16 support
+    assert onedal_queue.sycl_device.has_aspect_fp16 == queue.sycl_device.has_aspect_fp16
+    # check is_cpu
+    assert onedal_queue.sycl_device.is_cpu == queue.sycl_device.is_cpu
+    # check is_gpu
+    assert onedal_queue.sycl_device.is_gpu == queue.sycl_device.is_gpu
+    # check device number
+    assert onedal_queue.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(not backend.is_dpc, reason="requires dpc backend")
+def test_backend_queue():
+    try:
+        q = backend.SyclQueue("cpu")
+    except RuntimeError:
+        pytest.skip("OpenCL CPU runtime not installed")
+
+    # verify copying via a py capsule object is functional
+    q2 = backend.SyclQueue(q._get_capsule())
+    # verify copying via the _get_capsule attribute
+    q3 = backend.SyclQueue(q)
+    # create new queue on the same device for device checks
+    q4 = backend.SyclQueue("cpu")
+
+    q_array = [q, q2, q3]
+
+    assert all([queue.sycl_device.has_aspect_fp64 for queue in q_array])
+    assert all([queue.sycl_device.has_aspect_fp16 for queue in q_array])
+    assert all([queue.sycl_device.is_cpu for queue in q_array])
+    assert all([not queue.sycl_device.is_gpu for queue in q_array])
+    assert all(["cpu" in queue.sycl_device.filter_string for queue in q_array])
+    assert q.sycl_device == q4.sycl_device  # verify that __eq__ operator works
+    assert not (q.sycl_device != q4.sycl_device)  # verify that __ne__ operator works
+    assert q != q4  # verify two separate cpu queues created
+
+
+@pytest.mark.skipif(
+    not backend.is_dpc or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+def test_backend_device_id():
+    """verify dpctl device id matches our internal device id"""
+    import dpctl
+
+    for i in range(dpctl.get_num_devices()):
+        device = dpctl.SyclDevice(str(i))
+        if device.is_gpu or device.is_cpu:
+            backend_device = backend.SyclDevice(i)
+            assert (
+                i == backend_device.get_device_id()
+            ), f"backend id does not match device_id: {i}"

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

@@ -0,0 +1,20 @@
+# ===============================================================================
+# 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 .covariance import EmpiricalCovariance
+from .incremental_covariance import IncrementalEmpiricalCovariance
+
+__all__ = ["EmpiricalCovariance", "IncrementalEmpiricalCovariance"]