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

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/metrics/pairwise.py

@@ -15,8 +15,8 @@
 # ===============================================================================
 
 from daal4py.sklearn.metrics import pairwise_distances
-from onedal._device_offload import support_usm_ndarray
+from onedal._device_offload import support_input_format
 
-pairwise_distances = support_usm_ndarray(freefunc=True, queue_param=False)(
+pairwise_distances = support_input_format(freefunc=True, queue_param=False)(
     pairwise_distances
 )

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/metrics/ranking.py

@@ -15,6 +15,6 @@
 # ===============================================================================
 
 from daal4py.sklearn.metrics import roc_auc_score
-from onedal._device_offload import support_usm_ndarray
+from onedal._device_offload import support_input_format
 
-roc_auc_score = support_usm_ndarray(freefunc=True, queue_param=False)(roc_auc_score)
+roc_auc_score = support_input_format(freefunc=True, queue_param=False)(roc_auc_score)

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/model_selection/split.py

@@ -15,6 +15,8 @@
 # ===============================================================================
 
 from daal4py.sklearn.model_selection import train_test_split
-from onedal._device_offload import support_usm_ndarray
+from onedal._device_offload import support_input_format
 
-train_test_split = support_usm_ndarray(freefunc=True, queue_param=False)(train_test_split)
+train_test_split = support_input_format(freefunc=True, queue_param=False)(
+    train_test_split
+)

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/neighbors/_lof.py

@@ -26,7 +26,8 @@ from daal4py.sklearn._utils import sklearn_check_version
 from sklearnex._device_offload import dispatch, wrap_output_data
 from sklearnex.neighbors.common import KNeighborsDispatchingBase
 from sklearnex.neighbors.knn_unsupervised import NearestNeighbors
-from sklearnex.utils import get_namespace
+
+from ..utils._array_api import get_namespace
 
 
 @control_n_jobs(decorated_methods=["fit", "_kneighbors"])

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/neighbors/common.py

@@ -28,7 +28,7 @@ from daal4py.sklearn._utils import sklearn_check_version
 from onedal.utils import _check_array, _num_features, _num_samples
 
 from .._utils import PatchingConditionsChain
-from ..utils import get_namespace
+from ..utils._array_api import get_namespace
 
 
 class KNeighborsDispatchingBase:

{scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/preview/cluster → scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/preview}/__init__.py

@@ -14,6 +14,4 @@
 # limitations under the License.
 # ==============================================================================
 
-from .k_means import KMeans
-
-__all__ = ["KMeans"]
+__all__ = ["covariance", "decomposition", "linear_model"]

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/preview/decomposition/incremental_pca.py

@@ -61,7 +61,7 @@ class IncrementalPCA(sklearn_IncrementalPCA):
         return self._onedal_transform(X, queue)
 
     def _onedal_partial_fit(self, X, check_input=True, queue=None):
-        first_pass = not hasattr(self, "components_")
+        first_pass = not hasattr(self, "_onedal_estimator")
 
         if check_input:
             if sklearn_check_version("1.0"):
@@ -78,10 +78,10 @@ class IncrementalPCA(sklearn_IncrementalPCA):
         n_samples, n_features = X.shape
 
         if self.n_components is None:
-            if not hasattr(self, "components_"):
+            if not hasattr(self, "_components_shape"):
                 self.n_components_ = min(n_samples, n_features)
-            else:
-                self.n_components_ = self.components_.shape[0]
+                self._components_shape = self.n_components_
+
         elif not self.n_components <= n_features:
             raise ValueError(
                 "n_components=%r invalid for n_features=%d, need "
@@ -106,12 +106,12 @@ class IncrementalPCA(sklearn_IncrementalPCA):
 
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_pca(**onedal_params)
-        self._onedal_estimator.partial_fit(X, queue)
+        self._onedal_estimator.partial_fit(X, queue=queue)
         self._need_to_finalize = True
 
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
+        self._onedal_estimator.finalize_fit(queue=queue)
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, queue=None):
@@ -142,7 +142,7 @@ class IncrementalPCA(sklearn_IncrementalPCA):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue)
 
-        self._onedal_finalize_fit()
+        self._onedal_finalize_fit(queue=queue)
 
         return self
 

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/preview/decomposition/tests/test_incremental_pca.py

@@ -74,7 +74,7 @@ def check_pca_on_gold_data(incpca, dtype, whiten, transformed_data):
     )
 
     tol = 1e-7
-    if transformed_data.dtype == np.float32:
+    if dtype == np.float32:
         tol = 7e-6 if whiten else 1e-6
 
     assert incpca.n_samples_seen_ == expected_n_samples_seen_
@@ -112,7 +112,7 @@ def check_pca_on_gold_data(incpca, dtype, whiten, transformed_data):
 
 
 def check_pca(incpca, dtype, whiten, data, transformed_data):
-    tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
+    tol = 3e-3 if dtype == np.float32 else 2e-6
 
     n_components = incpca.n_components_
 

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/preview/linear_model/ridge.py

@@ -408,11 +408,11 @@ if daal_check_version((2024, "P", 600)):
 
 else:
     from daal4py.sklearn.linear_model._ridge import Ridge
-    from onedal._device_offload import support_usm_ndarray
+    from onedal._device_offload import support_input_format
 
-    Ridge.fit = support_usm_ndarray(queue_param=False)(Ridge.fit)
-    Ridge.predict = support_usm_ndarray(queue_param=False)(Ridge.predict)
-    Ridge.score = support_usm_ndarray(queue_param=False)(Ridge.score)
+    Ridge.fit = support_input_format(queue_param=False)(Ridge.fit)
+    Ridge.predict = support_input_format(queue_param=False)(Ridge.predict)
+    Ridge.score = support_input_format(queue_param=False)(Ridge.score)
 
     logging.warning(
         "Preview Ridge requires oneDAL version >= 2024.6 but it was not found"

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/spmd/basic_statistics/__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 .basic_statistics import BasicStatistics
+from .incremental_basic_statistics import IncrementalBasicStatistics
+
+__all__ = ["BasicStatistics", "IncrementalBasicStatistics"]

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/spmd/basic_statistics/incremental_basic_statistics.py

@@ -0,0 +1,30 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+
+from onedal.spmd.basic_statistics import (
+    IncrementalBasicStatistics as onedalSPMD_IncrementalBasicStatistics,
+)
+
+from ...basic_statistics import (
+    IncrementalBasicStatistics as base_IncrementalBasicStatistics,
+)
+
+
+class IncrementalBasicStatistics(base_IncrementalBasicStatistics):
+    _onedal_incremental_basic_statistics = staticmethod(
+        onedalSPMD_IncrementalBasicStatistics
+    )

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_incremental_basic_statistics_spmd.py

@@ -0,0 +1,307 @@
+# ==============================================================================
+# 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.basic_statistics.tests.test_basic_statistics import options_and_tests
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests._utils_spmd import (
+    _generate_statistic_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_basic_statistics_fit_spmd_gold(dataframe, queue, weighted, dtype):
+    # Import spmd and batch algo
+    from sklearnex.basic_statistics import IncrementalBasicStatistics
+    from sklearnex.spmd.basic_statistics import (
+        IncrementalBasicStatistics as IncrementalBasicStatistics_SPMD,
+    )
+
+    # Create gold data and process into dpt
+    data = np.array(
+        [
+            [0.0, 0.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, 2.0, 4.0],
+            [0.0, 3.0, 8.0],
+            [0.0, 4.0, 16.0],
+            [0.0, 5.0, 32.0],
+            [0.0, 6.0, 64.0],
+            [0.0, 7.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_data = _convert_to_dataframe(data, sycl_queue=queue, target_df=dataframe)
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    if weighted:
+        # Create weights array containing the weight for each sample in the data
+        weights = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=dtype)
+        dpt_weights = _convert_to_dataframe(
+            weights, sycl_queue=queue, target_df=dataframe
+        )
+        local_dpt_weights = _convert_to_dataframe(
+            _get_local_tensor(weights), sycl_queue=queue, target_df=dataframe
+        )
+
+    # ensure results of batch algo match spmd
+
+    incbs_spmd = IncrementalBasicStatistics_SPMD().fit(
+        local_dpt_data, sample_weight=local_dpt_weights if weighted else None
+    )
+    incbs = IncrementalBasicStatistics().fit(
+        dpt_data, sample_weight=dpt_weights if weighted else None
+    )
+
+    for option, _, _ in options_and_tests:
+        assert_allclose(
+            getattr(incbs_spmd, option),
+            getattr(incbs, option),
+            err_msg=f"Result for {option} is incorrect",
+        )
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_basic_statistics_partial_fit_spmd_gold(
+    dataframe, queue, num_blocks, weighted, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.basic_statistics import IncrementalBasicStatistics
+    from sklearnex.spmd.basic_statistics import (
+        IncrementalBasicStatistics as IncrementalBasicStatistics_SPMD,
+    )
+
+    # Create gold data and process into dpt
+    data = np.array(
+        [
+            [0.0, 0.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, 2.0, 4.0],
+            [0.0, 3.0, 8.0],
+            [0.0, 4.0, 16.0],
+            [0.0, 5.0, 32.0],
+            [0.0, 6.0, 64.0],
+            [0.0, 7.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_data = _convert_to_dataframe(data, sycl_queue=queue, target_df=dataframe)
+    local_data = _get_local_tensor(data)
+    split_local_data = np.array_split(local_data, num_blocks)
+
+    if weighted:
+        # Create weights array containing the weight for each sample in the data
+        weights = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=dtype)
+        dpt_weights = _convert_to_dataframe(
+            weights, sycl_queue=queue, target_df=dataframe
+        )
+        local_weights = _get_local_tensor(weights)
+        split_local_weights = np.array_split(local_weights, num_blocks)
+
+    incbs_spmd = IncrementalBasicStatistics_SPMD()
+    incbs = IncrementalBasicStatistics()
+
+    for i in range(num_blocks):
+        local_dpt_data = _convert_to_dataframe(
+            split_local_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            local_dpt_weights = _convert_to_dataframe(
+                split_local_weights[i], sycl_queue=queue, target_df=dataframe
+            )
+        incbs_spmd.partial_fit(
+            local_dpt_data, sample_weight=local_dpt_weights if weighted else None
+        )
+
+    incbs.fit(dpt_data, sample_weight=dpt_weights if weighted else None)
+
+    for option, _, _ in options_and_tests:
+        assert_allclose(
+            getattr(incbs_spmd, option),
+            getattr(incbs, option),
+            err_msg=f"Result for {option} is incorrect",
+        )
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("result_option", options_and_tests)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_basic_statistics_single_option_partial_fit_spmd_gold(
+    dataframe, queue, num_blocks, weighted, result_option, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.basic_statistics import IncrementalBasicStatistics
+    from sklearnex.spmd.basic_statistics import (
+        IncrementalBasicStatistics as IncrementalBasicStatistics_SPMD,
+    )
+
+    # Create gold data and process into dpt
+    data = np.array(
+        [
+            [0.0, 0.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, 2.0, 4.0],
+            [0.0, 3.0, 8.0],
+            [0.0, 4.0, 16.0],
+            [0.0, 5.0, 32.0],
+            [0.0, 6.0, 64.0],
+            [0.0, 7.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_data = _convert_to_dataframe(data, sycl_queue=queue, target_df=dataframe)
+    local_data = _get_local_tensor(data)
+    split_local_data = np.array_split(local_data, num_blocks)
+
+    if weighted:
+        # Create weights array containing the weight for each sample in the data
+        weights = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=dtype)
+        dpt_weights = _convert_to_dataframe(
+            weights, sycl_queue=queue, target_df=dataframe
+        )
+        local_weights = _get_local_tensor(weights)
+        split_local_weights = np.array_split(local_weights, num_blocks)
+
+    option, _, _ = result_option
+    incbs_spmd = IncrementalBasicStatistics_SPMD(result_options=option)
+    incbs = IncrementalBasicStatistics(result_options=option)
+
+    for i in range(num_blocks):
+        local_dpt_data = _convert_to_dataframe(
+            split_local_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            local_dpt_weights = _convert_to_dataframe(
+                split_local_weights[i], sycl_queue=queue, target_df=dataframe
+            )
+        incbs_spmd.partial_fit(
+            local_dpt_data, sample_weight=local_dpt_weights if weighted else None
+        )
+
+    incbs.fit(dpt_data, sample_weight=dpt_weights if weighted else None)
+
+    assert_allclose(getattr(incbs_spmd, option), getattr(incbs, option))
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("n_samples", [100, 10000])
+@pytest.mark.parametrize("n_features", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_basic_statistics_partial_fit_spmd_synthetic(
+    dataframe, queue, num_blocks, weighted, n_samples, n_features, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.basic_statistics import IncrementalBasicStatistics
+    from sklearnex.spmd.basic_statistics import (
+        IncrementalBasicStatistics as IncrementalBasicStatistics_SPMD,
+    )
+
+    tol = 2e-3 if dtype == np.float32 else 1e-7
+
+    # Create gold data and process into dpt
+    data = _generate_statistic_data(n_samples, n_features, dtype=dtype)
+    local_data = _get_local_tensor(data)
+    split_local_data = np.array_split(local_data, num_blocks)
+    split_data = np.array_split(data, num_blocks)
+
+    if weighted:
+        # Create weights array containing the weight for each sample in the data
+        weights = _generate_statistic_data(n_samples, dtype=dtype)
+        local_weights = _get_local_tensor(weights)
+        split_local_weights = np.array_split(local_weights, num_blocks)
+        split_weights = np.array_split(weights, num_blocks)
+
+    incbs_spmd = IncrementalBasicStatistics_SPMD()
+    incbs = IncrementalBasicStatistics()
+
+    for i in range(num_blocks):
+        local_dpt_data = _convert_to_dataframe(
+            split_local_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        dpt_data = _convert_to_dataframe(
+            split_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            local_dpt_weights = _convert_to_dataframe(
+                split_local_weights[i], sycl_queue=queue, target_df=dataframe
+            )
+            dpt_weights = _convert_to_dataframe(
+                split_weights[i], sycl_queue=queue, target_df=dataframe
+            )
+        incbs_spmd.partial_fit(
+            local_dpt_data, sample_weight=local_dpt_weights if weighted else None
+        )
+        incbs.partial_fit(dpt_data, sample_weight=dpt_weights if weighted else None)
+
+    for option, _, _ in options_and_tests:
+        assert_allclose(
+            getattr(incbs_spmd, option),
+            getattr(incbs, option),
+            atol=tol,
+            err_msg=f"Result for {option} is incorrect",
+        )

scikit_learn_intelex-2025.0.1.data/data/Lib/site-packages/sklearnex/spmd/covariance/__init__.py

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

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

@@ -0,0 +1,37 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+from onedal.spmd.covariance import (
+    IncrementalEmpiricalCovariance as onedalSPMD_IncrementalEmpiricalCovariance,
+)
+
+from ...covariance import (
+    IncrementalEmpiricalCovariance as base_IncrementalEmpiricalCovariance,
+)
+
+
+class IncrementalEmpiricalCovariance(base_IncrementalEmpiricalCovariance):
+    """
+    Incremental distributed estimator for covariance.
+    Allows to distributely compute empirical covariance estimated by maximum
+    likelihood method if data are splitted into batches.
+
+    API is the same as for `sklearnex.covariance.IncrementalEmpiricalCovariance`
+    """
+
+    _onedal_incremental_covariance = staticmethod(
+        onedalSPMD_IncrementalEmpiricalCovariance
+    )