scikit-learn-intelex 2024.6.0__py310-none-win_amd64.whl → 2024.7.0__py310-none-win_amd64.whl

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_basic_statistics_spmd.py

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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.mpi
+def test_basic_stats_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from onedal.basic_statistics import BasicStatistics as BasicStatistics_Batch
+    from sklearnex.spmd.basic_statistics import BasicStatistics as BasicStatistics_SPMD
+
+    # Create gold data and convert to dataframe
+    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],
+        ]
+    )
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = BasicStatistics_SPMD().fit(local_dpt_data)
+    batch_result = BasicStatistics_Batch().fit(data)
+
+    for option in (opt[0] for opt in options_and_tests):
+        assert_allclose(getattr(spmd_result, option), getattr(batch_result, option))
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [100, 10000])
+@pytest.mark.parametrize("n_features", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_basic_stats_spmd_synthetic(n_samples, n_features, dataframe, queue, dtype):
+    # Import spmd and batch algo
+    from onedal.basic_statistics import BasicStatistics as BasicStatistics_Batch
+    from sklearnex.spmd.basic_statistics import BasicStatistics as BasicStatistics_SPMD
+
+    # Generate data and convert to dataframe
+    data = _generate_statistic_data(n_samples, n_features, dtype=dtype)
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = BasicStatistics_SPMD().fit(local_dpt_data)
+    batch_result = BasicStatistics_Batch().fit(data)
+
+    tol = 1e-5 if dtype == np.float32 else 1e-7
+    for option in (opt[0] for opt in options_and_tests):
+        assert_allclose(
+            getattr(spmd_result, option),
+            getattr(batch_result, option),
+            atol=tol,
+            rtol=tol,
+        )

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/spmd/cluster/tests/test_dbscan_spmd.py

@@ -0,0 +1,97 @@
+# ==============================================================================
+# 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.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests._utils_spmd import (
+    _generate_clustering_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+    _spmd_assert_allclose,
+)
+
+
+@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.mpi
+def test_dbscan_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.cluster import DBSCAN as DBSCAN_Batch
+    from sklearnex.spmd.cluster import DBSCAN as DBSCAN_SPMD
+
+    data = np.array([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]])
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure labels from fit of batch algo matches spmd
+    spmd_model = DBSCAN_SPMD(eps=3, min_samples=2).fit(local_dpt_data)
+    batch_model = DBSCAN_Batch(eps=3, min_samples=2).fit(data)
+
+    _spmd_assert_allclose(spmd_model.labels_, batch_model.labels_)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [200, 10000])
+@pytest.mark.parametrize("n_features_and_eps", [(5, 3), (5, 10), (25, 10)])
+@pytest.mark.parametrize("centers", [10, None])
+@pytest.mark.parametrize("min_samples", [2, 5, 15])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_dbscan_spmd_synthetic(
+    n_samples, n_features_and_eps, centers, min_samples, dataframe, queue, dtype
+):
+    n_features, eps = n_features_and_eps
+    # Import spmd and batch algo
+    from sklearnex.cluster import DBSCAN as DBSCAN_Batch
+    from sklearnex.spmd.cluster import DBSCAN as DBSCAN_SPMD
+
+    data, _ = _generate_clustering_data(
+        n_samples, n_features, centers=centers, dtype=dtype
+    )
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure labels from fit of batch algo matches spmd
+    spmd_model = DBSCAN_SPMD(eps=eps, min_samples=min_samples).fit(local_dpt_data)
+    batch_model = DBSCAN_Batch(eps=eps, min_samples=min_samples).fit(data)
+
+    _spmd_assert_allclose(spmd_model.labels_, batch_model.labels_)
+
+    # Ensure meaningful test setup
+    if np.all(batch_model.labels_ == -1):
+        raise ValueError("No labels given - try raising epsilon")

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/spmd/cluster/tests/test_kmeans_spmd.py

@@ -0,0 +1,172 @@
+# ==============================================================================
+# 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._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests._utils_spmd import (
+    _assert_kmeans_labels_allclose,
+    _assert_unordered_allclose,
+    _generate_clustering_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.mpi
+def test_kmeans_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.cluster import KMeans as KMeans_Batch
+    from sklearnex.spmd.cluster import KMeans as KMeans_SPMD
+
+    X_train = np.array(
+        [
+            [1, 2],
+            [2, 2],
+            [2, 3],
+            [8, 7],
+            [8, 8],
+            [25, 80],
+            [5, 65],
+            [2, 8],
+            [1, 3],
+            [2, 2],
+            [1, 3],
+            [2, 2],
+        ]
+    )
+    X_test = np.array([[0, 0], [12, 3], [2, 2], [7, 8]])
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure labels from fit of batch algo matches spmd
+    spmd_model = KMeans_SPMD(n_clusters=2, random_state=0).fit(local_dpt_X_train)
+    batch_model = KMeans_Batch(n_clusters=2, random_state=0).fit(X_train)
+
+    _assert_unordered_allclose(spmd_model.cluster_centers_, batch_model.cluster_centers_)
+    _assert_kmeans_labels_allclose(
+        spmd_model.labels_,
+        batch_model.labels_,
+        spmd_model.cluster_centers_,
+        batch_model.cluster_centers_,
+    )
+    assert_allclose(spmd_model.n_iter_, batch_model.n_iter_, atol=1)
+
+    # Ensure predictions of batch algo match spmd
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    _assert_kmeans_labels_allclose(
+        spmd_result,
+        batch_result,
+        spmd_model.cluster_centers_,
+        batch_model.cluster_centers_,
+    )
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [200, 10000])
+@pytest.mark.parametrize("n_features", [5, 25])
+@pytest.mark.parametrize("n_clusters", [2, 5, 15])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_kmeans_spmd_synthetic(
+    n_samples, n_features, n_clusters, dataframe, queue, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.cluster import KMeans as KMeans_Batch
+    from sklearnex.spmd.cluster import KMeans as KMeans_SPMD
+
+    # TODO: investigate issues when centers != n_clusters (spmd and batch results don't match for all values of K)
+    X_train, X_test = _generate_clustering_data(
+        n_samples, n_features, centers=n_clusters, dtype=dtype
+    )
+
+    local_dpt_X_train = _convert_to_dataframe(
+        _get_local_tensor(X_train), sycl_queue=queue, target_df=dataframe
+    )
+    local_dpt_X_test = _convert_to_dataframe(
+        _get_local_tensor(X_test), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Validate KMeans init
+    spmd_model_init = KMeans_SPMD(n_clusters=n_clusters, max_iter=1, random_state=0).fit(
+        local_dpt_X_train
+    )
+    batch_model_init = KMeans_Batch(
+        n_clusters=n_clusters, max_iter=1, random_state=0
+    ).fit(X_train)
+    # TODO: centers do not match up after init
+    # _assert_unordered_allclose(spmd_model_init.cluster_centers_, batch_model_init.cluster_centers_)
+
+    # Ensure labels from fit of batch algo matches spmd, using same init
+    spmd_model = KMeans_SPMD(
+        n_clusters=n_clusters, init=spmd_model_init.cluster_centers_, random_state=0
+    ).fit(local_dpt_X_train)
+    batch_model = KMeans_Batch(
+        n_clusters=n_clusters, init=spmd_model_init.cluster_centers_, random_state=0
+    ).fit(X_train)
+
+    atol = 1e-5 if dtype == np.float32 else 1e-7
+    _assert_unordered_allclose(
+        spmd_model.cluster_centers_, batch_model.cluster_centers_, atol=atol
+    )
+    _assert_kmeans_labels_allclose(
+        spmd_model.labels_,
+        batch_model.labels_,
+        spmd_model.cluster_centers_,
+        batch_model.cluster_centers_,
+        atol=atol,
+    )
+    # TODO: KMeans iterations are not aligned
+    # assert_allclose(spmd_model.n_iter_, batch_model.n_iter_, atol=1)
+
+    # Ensure predictions of batch algo match spmd
+    spmd_result = spmd_model.predict(local_dpt_X_test)
+    batch_result = batch_model.predict(X_test)
+
+    _assert_kmeans_labels_allclose(
+        spmd_result,
+        batch_result,
+        spmd_model.cluster_centers_,
+        batch_model.cluster_centers_,
+        atol=atol,
+    )

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_covariance_spmd.py

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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._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.mpi
+def test_covariance_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from onedal.covariance import EmpiricalCovariance as EmpiricalCovariance_Batch
+    from sklearnex.spmd.covariance import EmpiricalCovariance as EmpiricalCovariance_SPMD
+
+    # Create gold data and convert to dataframe
+    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],
+        ]
+    )
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = EmpiricalCovariance_SPMD().fit(local_dpt_data)
+    batch_result = EmpiricalCovariance_Batch().fit(data)
+
+    assert_allclose(spmd_result.covariance_, batch_result.covariance_)
+    assert_allclose(spmd_result.location_, batch_result.location_)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [100, 10000])
+@pytest.mark.parametrize("n_features", [10, 100])
+@pytest.mark.parametrize("assume_centered", [True, False])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_covariance_spmd_synthetic(
+    n_samples, n_features, assume_centered, dataframe, queue, dtype
+):
+    # Import spmd and batch algo
+    # TODO: Align sklearnex spmd to sklearnex estimator with bias and swap onedal with sklearnex
+    from onedal.covariance import EmpiricalCovariance as EmpiricalCovariance_Batch
+    from sklearnex.spmd.covariance import EmpiricalCovariance as EmpiricalCovariance_SPMD
+
+    # Generate data and convert to dataframe
+    data = _generate_statistic_data(n_samples, n_features, dtype=dtype)
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = EmpiricalCovariance_SPMD(assume_centered=assume_centered).fit(
+        local_dpt_data
+    )
+    batch_result = EmpiricalCovariance_Batch(assume_centered=assume_centered).fit(data)
+
+    atol = 1e-5 if dtype == np.float32 else 1e-7
+    assert_allclose(spmd_result.covariance_, batch_result.covariance_, atol=atol)
+    assert_allclose(spmd_result.location_, batch_result.location_, atol=atol)

scikit_learn_intelex-2024.7.0.data/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_pca_spmd.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 numpy.testing import assert_allclose
+
+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.mpi
+def test_pca_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.decomposition import PCA as PCA_Batch
+    from sklearnex.spmd.decomposition import PCA as PCA_SPMD
+
+    # Create gold data and convert to dataframe
+    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],
+        ]
+    )
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = PCA_SPMD(n_components=2).fit(local_dpt_data)
+    batch_result = PCA_Batch(n_components=2).fit(data)
+
+    assert_allclose(spmd_result.mean_, batch_result.mean_)
+    assert_allclose(spmd_result.components_, batch_result.components_)
+    assert_allclose(spmd_result.singular_values_, batch_result.singular_values_)
+    assert_allclose(
+        spmd_result.noise_variance_,
+        batch_result.noise_variance_,
+        atol=1e-7,
+    )
+    assert_allclose(
+        spmd_result.explained_variance_ratio_, batch_result.explained_variance_ratio_
+    )
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [100, 10000])
+@pytest.mark.parametrize("n_features", [10, 100])
+@pytest.mark.parametrize("n_components", [0.5, 3, "mle", None])
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_pca_spmd_synthetic(
+    n_samples, n_features, n_components, whiten, dataframe, queue, dtype
+):
+    # TODO: Resolve issues with batch fallback and lack of support for n_rows_rank < n_cols
+    if n_components == "mle" or n_components == 3:
+        pytest.skip("Avoid error in case of batch fallback to sklearn")
+    if n_samples <= n_features:
+        pytest.skip("Avoid n_samples < n_features error from spmd data split")
+
+    # Import spmd and batch algo
+    from sklearnex.decomposition import PCA as PCA_Batch
+    from sklearnex.spmd.decomposition import PCA as PCA_SPMD
+
+    # Generate data and convert to dataframe
+    data = _generate_statistic_data(n_samples, n_features, dtype=dtype)
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = PCA_SPMD(n_components=n_components, whiten=whiten).fit(local_dpt_data)
+    batch_result = PCA_Batch(n_components=n_components, whiten=whiten).fit(data)
+
+    tol = 1e-3 if dtype == np.float32 else 1e-7
+    assert_allclose(spmd_result.mean_, batch_result.mean_, atol=tol)
+    assert_allclose(spmd_result.components_, batch_result.components_, atol=tol, rtol=tol)
+    assert_allclose(spmd_result.singular_values_, batch_result.singular_values_, atol=tol)
+    assert_allclose(spmd_result.noise_variance_, batch_result.noise_variance_, atol=tol)
+    assert_allclose(
+        spmd_result.explained_variance_ratio_,
+        batch_result.explained_variance_ratio_,
+        atol=tol,
+    )