scikit-learn-intelex 2025.4.0__py313-none-manylinux_2_28_x86_64.whl

onedal/common/hyperparameters.py

@@ -0,0 +1,125 @@
+# ==============================================================================
+# 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 Any, Dict, Tuple
+from warnings import warn
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal import _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], Any] = {
+        (
+            "linear_regression",
+            "train",
+        ): _backend.linear_model.regression.train_hyperparameters(),
+        ("covariance", "compute"): _backend.covariance.compute_hyperparameters(),
+    }
+    if daal_check_version((2024, "P", 300)):
+        df_infer_hp = _backend.decision_forest.infer_hyperparameters
+        hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
+    hyperparameters_map = {}
+
+    for (algorithm, op), hyperparameters in hyperparameters_backend.items():
+        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(algorithm, op):
+    return hyperparameters_map.get((algorithm, op), None)

onedal/common/tests/test_policy.py

@@ -0,0 +1,76 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import numpy as np
+import pytest
+
+from onedal.common._policy import _get_policy
+from onedal.tests.utils._device_selection import (
+    device_type_to_str,
+    get_memory_usm,
+    get_queues,
+    is_dpctl_device_available,
+)
+from onedal.utils._dpep_helpers import dpctl_available
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_queue_passed_directly(queue):
+    device_name = device_type_to_str(queue)
+    test_queue = _get_policy(queue)
+    test_device_name = test_queue.get_device_name()
+    assert test_device_name == device_name
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_with_numpy_data(queue):
+    X = np.zeros((5, 3))
+    y = np.zeros(3)
+
+    device_name = device_type_to_str(queue)
+    assert _get_policy(queue, X, y).get_device_name() == device_name
+
+
+@pytest.mark.skipif(not dpctl_available, reason="depends on dpctl")
+@pytest.mark.parametrize("queue", get_queues("cpu,gpu"))
+@pytest.mark.parametrize("memtype", get_memory_usm())
+def test_with_usm_ndarray_data(queue, memtype):
+    if queue is None:
+        pytest.skip(
+            "dpctl Memory object with queue=None uses cached default (gpu if available)"
+        )
+
+    from dpctl.tensor import usm_ndarray
+
+    device_name = device_type_to_str(queue)
+    X = usm_ndarray((5, 3), buffer=memtype(5 * 3 * 8, queue=queue))
+    y = usm_ndarray((3,), buffer=memtype(3 * 8, queue=queue))
+    assert _get_policy(None, X, y).get_device_name() == device_name
+
+
+@pytest.mark.skipif(
+    not is_dpctl_device_available(["cpu", "gpu"]), reason="test uses multiple devices"
+)
+@pytest.mark.parametrize("memtype", get_memory_usm())
+def test_queue_parameter_with_usm_ndarray(memtype):
+    from dpctl import SyclQueue
+    from dpctl.tensor import usm_ndarray
+
+    q1 = SyclQueue("cpu")
+    q2 = SyclQueue("gpu")
+
+    X = usm_ndarray((5, 3), buffer=memtype(5 * 3 * 8, queue=q1))
+    assert _get_policy(q2, X).get_device_name() == device_type_to_str(q2)

onedal/common/tests/test_sycl.py

@@ -0,0 +1,128 @@
+# ==============================================================================
+# 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
+import pytest
+
+from onedal import _backend, _is_dpc_backend
+from onedal.tests.utils._device_selection import get_queues
+from onedal.utils._dpep_helpers import dpctl_available
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend 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 _is_dpc_backend 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 _is_dpc_backend 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 _is_dpc_backend, 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)
+
+    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])

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"]

onedal/covariance/covariance.py

@@ -0,0 +1,122 @@
+# ===============================================================================
+# 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 abc import ABCMeta
+
+import numpy as np
+
+from daal4py.sklearn._utils import daal_check_version, get_dtype
+from onedal.utils import _check_array
+
+from ..common._base import BaseEstimator
+from ..common.hyperparameters import get_hyperparameters
+from ..datatypes import from_table, to_table
+
+
+class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
+    def __init__(self, method="dense", bias=False, assume_centered=False):
+        self.method = method
+        self.bias = bias
+        self.assume_centered = assume_centered
+
+    def _get_onedal_params(self, dtype=np.float32):
+        params = {
+            "fptype": dtype,
+            "method": self.method,
+        }
+        if daal_check_version((2024, "P", 1)):
+            params["bias"] = self.bias
+        if daal_check_version((2024, "P", 400)):
+            params["assumeCentered"] = self.assume_centered
+
+        return params
+
+
+class EmpiricalCovariance(BaseEmpiricalCovariance):
+    """Covariance estimator.
+
+    Computes sample covariance matrix.
+
+    Parameters
+    ----------
+    method : string, default="dense"
+        Specifies computation method. Available methods: "dense".
+
+    bias: bool, default=False
+        If True biased estimation of covariance is computed which equals to
+        the unbiased one multiplied by (n_samples - 1) / n_samples.
+
+    assume_centered : bool, default=False
+        If True, data are not centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False (default), data are centered before computation.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e., the estimated mean.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix
+    """
+
+    def fit(self, X, y=None, queue=None):
+        """Fit the sample covariance matrix of X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples, and
+            `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        policy = self._get_policy(queue, X)
+        X = _check_array(X, dtype=[np.float64, np.float32])
+        X = to_table(X, queue=queue)
+        params = self._get_onedal_params(X.dtype)
+        hparams = get_hyperparameters("covariance", "compute")
+        if hparams is not None and not hparams.is_default:
+            result = self._get_backend(
+                "covariance",
+                None,
+                "compute",
+                policy,
+                params,
+                hparams.backend,
+                X,
+            )
+        else:
+            result = self._get_backend("covariance", None, "compute", policy, params, X)
+        if daal_check_version((2024, "P", 1)) or (not self.bias):
+            self.covariance_ = from_table(result.cov_matrix)
+        else:
+            self.covariance_ = (
+                from_table(result.cov_matrix) * (X.shape[0] - 1) / X.shape[0]
+            )
+
+        self.location_ = from_table(result.means).ravel()
+
+        return self

onedal/covariance/incremental_covariance.py

@@ -0,0 +1,161 @@
+# ===============================================================================
+# 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 daal_check_version, get_dtype
+
+from ..datatypes import from_table, to_table
+from ..utils import _check_array
+from .covariance import BaseEmpiricalCovariance
+
+
+class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
+    """
+    Covariance estimator based on oneDAL implementation.
+
+    Computes sample covariance matrix.
+
+    Parameters
+    ----------
+    method : string, default="dense"
+        Specifies computation method. Available methods: "dense".
+
+    bias: bool, default=False
+        If True biased estimation of covariance is computed which equals to
+        the unbiased one multiplied by (n_samples - 1) / n_samples.
+
+    assume_centered : bool, default=False
+        If True, data are not centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False (default), data are centered before computation.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e., the estimated mean.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix
+    """
+
+    def __init__(self, method="dense", bias=False, assume_centered=False):
+        super().__init__(method, bias, assume_centered)
+        self._reset()
+
+    def _reset(self):
+        self._need_to_finalize = False
+        self._partial_result = self._get_backend(
+            "covariance", None, "partial_compute_result"
+        )
+
+    def __getstate__(self):
+        # Since finalize_fit can't be dispatched without directly provided queue
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
+
+    def partial_fit(self, X, y=None, queue=None):
+        """
+        Computes partial data for the covariance matrix
+        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.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = _check_array(X, dtype=[np.float64, np.float32], ensure_2d=True)
+
+        self._queue = queue
+
+        policy = self._get_policy(queue, X)
+
+        X_table = to_table(X, queue=queue)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = X_table.dtype
+
+        params = self._get_onedal_params(self._dtype)
+        self._partial_result = self._get_backend(
+            "covariance",
+            None,
+            "partial_compute",
+            policy,
+            params,
+            self._partial_result,
+            X_table,
+        )
+        self._need_to_finalize = True
+
+    def finalize_fit(self, queue=None):
+        """
+        Finalizes covariance matrix and obtains `covariance_` and `location_`
+        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 self._need_to_finalize:
+            params = self._get_onedal_params(self._dtype)
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+
+            result = self._get_backend(
+                "covariance",
+                None,
+                "finalize_compute",
+                policy,
+                params,
+                self._partial_result,
+            )
+            if daal_check_version((2024, "P", 1)) or (not self.bias):
+                self.covariance_ = from_table(result.cov_matrix)
+            else:
+                n_rows = self._partial_result.partial_n_rows
+                self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
+
+            self.location_ = from_table(result.means).ravel()
+
+            self._need_to_finalize = False
+
+        return self

onedal/covariance/tests/test_covariance.py

@@ -0,0 +1,50 @@
+# ===============================================================================
+# 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 numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_onedal_import_covariance(queue):
+    from onedal.covariance import EmpiricalCovariance
+
+    X = np.array([[0, 1], [0, 1]])
+    result = EmpiricalCovariance().fit(X, queue=queue)
+    expected_covariance = np.array([[0, 0], [0, 0]])
+    expected_means = np.array([0, 1])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)
+
+    X = np.array([[1, 2], [3, 6]])
+    result = EmpiricalCovariance().fit(X, queue=queue)
+    expected_covariance = np.array([[2, 4], [4, 8]])
+    expected_means = np.array([2, 4])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)
+
+    X = np.array([[1, 2], [3, 6]])
+    result = EmpiricalCovariance(bias=True).fit(X, queue=queue)
+    expected_covariance = np.array([[1, 2], [2, 4]])
+    expected_means = np.array([2, 4])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)