scikit-learn-intelex 2024.7.0__py311-none-win_amd64.whl → 2025.0.1__py311-none-win_amd64.whl

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/common/tests/test_policy.py

@@ -0,0 +1,75 @@
+# ==============================================================================
+# 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_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 is_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_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)

scikit_learn_intelex-2025.0.1.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"]

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/covariance/covariance.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.
+# ===============================================================================
+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 _convert_to_supported, 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": "float" if dtype == np.float32 else "double",
+            "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 = _convert_to_supported(policy, X)
+        dtype = get_dtype(X)
+        params = self._get_onedal_params(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,
+                to_table(X),
+            )
+        else:
+            result = self._get_backend(
+                "covariance", None, "compute", policy, params, to_table(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

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/covariance/incremental_covariance.py

@@ -0,0 +1,146 @@
+# ===============================================================================
+# 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 _convert_to_supported, 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._partial_result = self._get_backend(
+            "covariance", None, "partial_compute_result"
+        )
+
+    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 = _convert_to_supported(policy, X)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = get_dtype(X)
+
+        params = self._get_onedal_params(self._dtype)
+        table_X = to_table(X)
+        self._partial_result = self._get_backend(
+            "covariance",
+            None,
+            "partial_compute",
+            policy,
+            params,
+            self._partial_result,
+            table_X,
+        )
+
+    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.
+        """
+        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()
+
+        return self

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/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_)

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/covariance/tests/test_incremental_covariance.py

@@ -0,0 +1,122 @@
+# ===============================================================================
+# 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 numpy.testing import assert_allclose
+
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_on_gold_data_unbiased(queue, dtype):
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    X = np.array([[0, 1], [0, 1]])
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov = IncrementalEmpiricalCovariance()
+
+    for i in range(2):
+        inccov.partial_fit(X_split[i], queue=queue)
+    result = inccov.finalize_fit()
+
+    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]])
+    X_split = np.array_split(X, 2)
+    X = X.astype(dtype)
+    inccov = IncrementalEmpiricalCovariance()
+
+    for i in range(2):
+        inccov.partial_fit(X_split[i], queue=queue)
+    result = inccov.finalize_fit()
+
+    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_)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_on_gold_data_biased(queue, dtype):
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    X = np.array([[0, 1], [0, 1]])
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov = IncrementalEmpiricalCovariance(bias=True)
+
+    for i in range(2):
+        inccov.partial_fit(X_split[i], queue=queue)
+    result = inccov.finalize_fit()
+
+    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]])
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov = IncrementalEmpiricalCovariance(bias=True)
+
+    for i in range(2):
+        inccov.partial_fit(X_split[i], queue=queue)
+    result = inccov.finalize_fit()
+
+    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_)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("num_batches", [2, 4, 6, 8, 10])
+@pytest.mark.parametrize("row_count", [100, 1000, 2000])
+@pytest.mark.parametrize("column_count", [10, 100, 200])
+@pytest.mark.parametrize("bias", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_on_random_data(
+    queue, num_batches, row_count, column_count, bias, dtype
+):
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, num_batches)
+    inccov = IncrementalEmpiricalCovariance(bias=bias)
+
+    for i in range(num_batches):
+        inccov.partial_fit(X_split[i], queue=queue)
+    result = inccov.finalize_fit()
+
+    expected_covariance = np.cov(X.T, bias=bias)
+    expected_means = np.mean(X, axis=0)
+
+    assert_allclose(expected_covariance, result.covariance_, atol=1e-6)
+    assert_allclose(expected_means, result.location_, atol=1e-6)

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from ._data_conversion import _convert_to_supported, from_table, to_table
+
+__all__ = ["from_table", "to_table", "_convert_to_supported"]

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -0,0 +1,95 @@
+# ==============================================================================
+# 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 warnings
+
+import numpy as np
+
+from daal4py.sklearn._utils import make2d
+from onedal import _backend, _is_dpc_backend
+
+from ..utils import _is_csr
+
+try:
+    import dpctl
+    import dpctl.tensor as dpt
+
+    dpctl_available = dpctl.__version__ >= "0.14"
+except ImportError:
+    dpctl_available = False
+
+
+def _apply_and_pass(func, *args):
+    if len(args) == 1:
+        return func(args[0])
+    return tuple(map(func, args))
+
+
+def from_table(*args):
+    return _apply_and_pass(_backend.from_table, *args)
+
+
+def convert_one_to_table(arg):
+    if dpctl_available:
+        if isinstance(arg, dpt.usm_ndarray):
+            return _backend.dpctl_to_table(arg)
+
+    if not _is_csr(arg):
+        arg = make2d(arg)
+    return _backend.to_table(arg)
+
+
+def to_table(*args):
+    return _apply_and_pass(convert_one_to_table, *args)
+
+
+if _is_dpc_backend:
+    from ..common._policy import _HostInteropPolicy
+
+    def _convert_to_supported(policy, *data):
+        def func(x):
+            return x
+
+        # CPUs support FP64 by default
+        if isinstance(policy, _HostInteropPolicy):
+            return _apply_and_pass(func, *data)
+
+        # It can be either SPMD or DPCPP policy
+        device = policy._queue.sycl_device
+
+        def convert_or_pass(x):
+            if (x is not None) and (x.dtype == np.float64):
+                warnings.warn(
+                    "Data will be converted into float32 from "
+                    "float64 because device does not support it",
+                    RuntimeWarning,
+                )
+                return x.astype(np.float32)
+            else:
+                return x
+
+        if not device.has_aspect_fp64:
+            func = convert_or_pass
+
+        return _apply_and_pass(func, *data)
+
+else:
+
+    def _convert_to_supported(policy, *data):
+        def func(x):
+            return x
+
+        return _apply_and_pass(func, *data)