scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

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

@@ -0,0 +1,121 @@
+# ===============================================================================
+# 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
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+
+from .._config import _get_config
+from ..common.hyperparameters import get_hyperparameters
+from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
+
+
+class BaseEmpiricalCovariance(metaclass=ABCMeta):
+    def __init__(self, method="dense", bias=False, assume_centered=False):
+        self.method = method
+        self.bias = bias
+        self.assume_centered = assume_centered
+
+    @bind_default_backend("covariance")
+    def compute(self, *args, **kwargs): ...
+
+    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 : str, 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
+    """
+
+    @supports_queue
+    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.
+        """
+
+        X_table = to_table(X, queue=queue)
+
+        params = self._get_onedal_params(X_table.dtype)
+        hparams = get_hyperparameters("covariance", "compute")
+        if hparams is not None and not hparams.is_default:
+            result = self.compute(params, hparams.backend, X_table)
+        else:
+            result = self.compute(params, X_table)
+        if daal_check_version((2024, "P", 1)) or (not self.bias):
+            self.covariance_ = from_table(result.cov_matrix, like=X)
+        else:
+            self.covariance_ = (
+                from_table(result.cov_matrix, like=X) * (X.shape[0] - 1) / X.shape[0]
+            )
+
+        self.location_ = from_table(result.means, like=X)[0, ...]
+
+        return self

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

@@ -0,0 +1,151 @@
+# ===============================================================================
+# 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
+
+from .._config import _get_config
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array
+from .covariance import BaseEmpiricalCovariance
+
+
+class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
+    """Covariance estimator based on oneDAL implementation.
+
+    Computes sample covariance matrix.
+
+    Parameters
+    ----------
+    method : str, 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()
+        self._queue = None
+
+    @bind_default_backend("covariance")
+    def partial_compute(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("covariance")
+    def partial_compute_result(self): ...
+
+    @bind_default_backend("covariance")
+    def finalize_compute(self, params, partial_result): ...
+
+    def _reset(self):
+        self._need_to_finalize = False
+        self._queue = None
+        self._outtype = None
+        self._partial_result = self.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
+
+    @supports_queue
+    def partial_fit(self, X, y=None, queue=None):
+        """Generate partial covariance from batch data in `_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 : SyclQueue or None, default=None
+            If not None, use this queue for computation.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+        self._queue = queue
+        if not self._outtype:
+            self._outtype = return_type_constructor(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.partial_compute(params, self._partial_result, X_table)
+        self._need_to_finalize = True
+
+    def finalize_fit(self):
+        """Finalize covariance matrix from the current `_partial_result`.
+
+        Results are stored in `location_` and `covariance_` attributes.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        if self._need_to_finalize:
+            params = self._get_onedal_params(self._dtype)
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_compute(params, self._partial_result)
+
+            self.covariance_ = from_table(result.cov_matrix, like=self._outtype)
+
+            if self.bias and not daal_check_version((2024, "P", 1)):
+                n_rows = self._partial_result.partial_n_rows
+                self.covariance_ *= (n_rows - 1) / n_rows
+
+            self.location_ = from_table(result.means, like=self._outtype)[0, ...]
+            self._outtype = None
+
+            self._need_to_finalize = False
+
+        return self

scikit_learn_intelex-2025.10.0.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]], dtype=np.float64)
+    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]], dtype=np.float64)
+    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]], dtype=np.float64)
+    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.10.0.data/data/Lib/site-packages/onedal/covariance/tests/test_incremental_covariance.py

@@ -0,0 +1,190 @@
+# ===============================================================================
+# 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.datatypes import from_table
+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 = 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([[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)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    inccov = IncrementalEmpiricalCovariance()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov.partial_fit(X_split[0], queue=queue)
+    inccov_loaded.partial_fit(X_split[0], queue=queue)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert inccov_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(inccov._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(inccov_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(inccov._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        inccov_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sums = from_table(inccov._partial_result.partial_sums)
+    partial_sums_loaded = from_table(inccov_loaded._partial_result.partial_sums)
+    assert_allclose(partial_sums, partial_sums_loaded)
+
+    inccov.partial_fit(X_split[1], queue=queue)
+    inccov_loaded.partial_fit(X_split[1], queue=queue)
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == False
+
+    inccov.finalize_fit()
+    inccov_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert_allclose(inccov.location_, inccov_loaded.location_, atol=1e-6)
+    assert_allclose(inccov.covariance_, inccov_loaded.covariance_, atol=1e-6)

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

@@ -0,0 +1,29 @@
+# ==============================================================================
+# 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 from_table, return_type_constructor, to_table
+from ._dlpack import dlpack_to_numpy, get_torch_queue
+from ._sycl_usm import copy_to_dpnp, copy_to_usm
+
+__all__ = [
+    "copy_to_dpnp",
+    "copy_to_usm",
+    "dlpack_to_numpy",
+    "from_table",
+    "get_torch_queue",
+    "to_table",
+    "return_type_constructor",
+]