scikit-learn-intelex 2024.1.0__py310-none-win_amd64.whl → 2025.1.0__py310-none-win_amd64.whl

scikit_learn_intelex-2025.1.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-2025.1.0.data/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_incremental_covariance_spmd.py

@@ -0,0 +1,184 @@
+# ==============================================================================
+# 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.parametrize("assume_centered", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_covariance_fit_spmd_gold(dataframe, queue, assume_centered, dtype):
+    # Import spmd and batch algo
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+    from sklearnex.spmd.covariance import (
+        IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_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
+    )
+
+    # ensure results of batch algo match spmd
+    spmd_result = IncrementalEmpiricalCovariance_SPMD(
+        assume_centered=assume_centered
+    ).fit(local_dpt_data)
+    non_spmd_result = IncrementalEmpiricalCovariance(assume_centered=assume_centered).fit(
+        dpt_data
+    )
+
+    assert_allclose(spmd_result.covariance_, non_spmd_result.covariance_)
+    assert_allclose(spmd_result.location_, non_spmd_result.location_)
+
+
+@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("assume_centered", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_covariance_partial_fit_spmd_gold(
+    dataframe, queue, num_blocks, assume_centered, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+    from sklearnex.spmd.covariance import (
+        IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_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)
+
+    inccov_spmd = IncrementalEmpiricalCovariance_SPMD(assume_centered=assume_centered)
+    inccov = IncrementalEmpiricalCovariance(assume_centered=assume_centered)
+
+    for i in range(num_blocks):
+        local_dpt_data = _convert_to_dataframe(
+            split_local_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        inccov_spmd.partial_fit(local_dpt_data)
+
+    inccov.fit(dpt_data)
+
+    assert_allclose(inccov_spmd.covariance_, inccov.covariance_)
+    assert_allclose(inccov_spmd.location_, inccov.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("num_blocks", [1, 2])
+@pytest.mark.parametrize("assume_centered", [True, False])
+@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_incremental_covariance_partial_fit_spmd_synthetic(
+    n_samples, n_features, num_blocks, assume_centered, dataframe, queue, dtype
+):
+    # Import spmd and batch algo
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+    from sklearnex.spmd.covariance import (
+        IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_SPMD,
+    )
+
+    # Generate data and process into dpt
+    data = _generate_statistic_data(n_samples, n_features, 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)
+
+    inccov_spmd = IncrementalEmpiricalCovariance_SPMD(assume_centered=assume_centered)
+    inccov = IncrementalEmpiricalCovariance(assume_centered=assume_centered)
+
+    for i in range(num_blocks):
+        local_dpt_data = _convert_to_dataframe(
+            split_local_data[i], sycl_queue=queue, target_df=dataframe
+        )
+        inccov_spmd.partial_fit(local_dpt_data)
+
+    inccov.fit(dpt_data)
+
+    tol = 1e-7
+
+    assert_allclose(inccov_spmd.covariance_, inccov.covariance_, atol=tol)
+    assert_allclose(inccov_spmd.location_, inccov.location_, atol=tol)

{scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex/spmd/basic_statistics → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/spmd/decomposition}/__init__.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from .basic_statistics import BasicStatistics
+from .incremental_pca import IncrementalPCA
+from .pca import PCA
 
-__all__ = ["BasicStatistics"]
+__all__ = ["IncrementalPCA", "PCA"]

scikit_learn_intelex-2024.1.0.data/data/Lib/site-packages/sklearnex/tests/test_n_jobs_support.py → scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/spmd/decomposition/incremental_pca.py

@@ -1,5 +1,5 @@
 # ==============================================================================
-# Copyright 2023 Intel Corporation
+# 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.
@@ -14,18 +14,17 @@
 # limitations under the License.
 # ==============================================================================
 
-import pytest
+from onedal.spmd.decomposition import IncrementalPCA as onedalSPMD_IncrementalPCA
 
-from sklearnex.cluster import KMeans
-from sklearnex.linear_model import ElasticNet, Lasso, Ridge
-from sklearnex.svm import SVC, SVR, NuSVC, NuSVR
+from ...preview.decomposition import IncrementalPCA as base_IncrementalPCA
 
-estimators = [KMeans, SVC, SVR, NuSVC, NuSVR, Lasso, Ridge, ElasticNet]
 
+class IncrementalPCA(base_IncrementalPCA):
+    """
+    Distributed incremental estimator for PCA based on sklearnex implementation.
+    Allows for distributed PCA computation if data is split into batches.
 
-@pytest.mark.parametrize("estimator", estimators)
-def test_n_jobs_support(estimator):
-    # use `n_jobs` parameter where original sklearn doesn't expect it
-    estimator(n_jobs=1)
-    # check `n_jobs` parameter doc entry
-    assert "n_jobs" in estimator.__doc__
+    API is the same as for `sklearnex.decomposition.IncrementalPCA`
+    """
+
+    _onedal_incremental_pca = staticmethod(onedalSPMD_IncrementalPCA)

scikit_learn_intelex-2025.1.0.data/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_incremental_pca_spmd.py

@@ -0,0 +1,269 @@
+# ==============================================================================
+# 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 (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.tests.utils.spmd import (
+    _generate_statistic_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+)
+
+attributes_to_compare = [
+    "n_components_",
+    "components_",
+    "singular_values_",
+    "mean_",
+    "var_",
+    "explained_variance_",
+    "explained_variance_ratio_",
+]
+
+
+@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("whiten", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_pca_fit_spmd_gold(dataframe, queue, whiten, dtype):
+    # Import spmd and non-SPMD algo
+    from sklearnex.preview.decomposition import IncrementalPCA
+    from sklearnex.spmd.decomposition import IncrementalPCA as IncrementalPCA_SPMD
+
+    # Create gold data and process into dpt
+    X = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 2.0],
+            [2.0, 4.0],
+            [3.0, 8.0],
+            [4.0, 16.0],
+            [5.0, 32.0],
+            [6.0, 64.0],
+            [7.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    dpt_X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X)
+    local_dpt_X = _convert_to_dataframe(local_X, sycl_queue=queue, target_df=dataframe)
+
+    incpca_spmd = IncrementalPCA_SPMD(whiten=whiten)
+    incpca = IncrementalPCA(whiten=whiten)
+
+    incpca_spmd.fit(local_dpt_X)
+    incpca.fit(dpt_X)
+
+    for attribute in attributes_to_compare:
+        assert_allclose(
+            getattr(incpca, attribute),
+            getattr(incpca_spmd, attribute),
+            err_msg=f"{attribute} 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("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_pca_partial_fit_spmd_gold(
+    dataframe, queue, whiten, num_blocks, dtype
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.preview.decomposition import IncrementalPCA
+    from sklearnex.spmd.decomposition import IncrementalPCA as IncrementalPCA_SPMD
+
+    # Create gold data and process into dpt
+    X = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 2.0],
+            [2.0, 4.0],
+            [3.0, 8.0],
+            [4.0, 16.0],
+            [5.0, 32.0],
+            [6.0, 64.0],
+            [7.0, 128.0],
+            [8.0, 0.0],
+            [9.0, 2.0],
+            [10.0, 4.0],
+            [11.0, 8.0],
+            [12.0, 16.0],
+            [13.0, 32.0],
+            [14.0, 64.0],
+            [15.0, 128.0],
+        ],
+        dtype=dtype,
+    )
+    X_split = np.array_split(X, num_blocks)
+    local_X = _get_local_tensor(X)
+    split_local_X = np.array_split(local_X, num_blocks)
+
+    incpca_spmd = IncrementalPCA_SPMD(whiten=whiten)
+    incpca = IncrementalPCA(whiten=whiten)
+
+    for i in range(num_blocks):
+        local_dpt_X = _convert_to_dataframe(
+            split_local_X[i], sycl_queue=queue, target_df=dataframe
+        )
+        dpt_X = _convert_to_dataframe(X_split[i], sycl_queue=queue, target_df=dataframe)
+        incpca.partial_fit(dpt_X)
+        incpca_spmd.partial_fit(local_dpt_X)
+
+    for attribute in attributes_to_compare:
+        assert_allclose(
+            getattr(incpca, attribute),
+            getattr(incpca_spmd, attribute),
+            err_msg=f"{attribute} 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("whiten", [True, False])
+@pytest.mark.parametrize("n_components", [None, 2, 5])
+@pytest.mark.parametrize("num_samples", [100, 200])
+@pytest.mark.parametrize("num_features", [10, 20])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_pca_fit_spmd_random(
+    dataframe, queue, whiten, n_components, num_samples, num_features, dtype
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.preview.decomposition import IncrementalPCA
+    from sklearnex.spmd.decomposition import IncrementalPCA as IncrementalPCA_SPMD
+
+    # Increased test dataset size requires a higher tol setting in comparison to other tests
+    tol = 7e-5 if dtype == np.float32 else 1e-7
+
+    # Create data and process into dpt
+    X = _generate_statistic_data(num_samples, num_features, dtype)
+    dpt_X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_test = _generate_statistic_data(num_samples // 5, num_features, dtype)
+    dpt_X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X)
+    local_dpt_X = _convert_to_dataframe(local_X, sycl_queue=queue, target_df=dataframe)
+
+    incpca_spmd = IncrementalPCA_SPMD(n_components=n_components, whiten=whiten)
+    incpca = IncrementalPCA(n_components=n_components, whiten=whiten)
+
+    incpca_spmd.fit(local_dpt_X)
+    incpca.fit(dpt_X)
+
+    for attribute in attributes_to_compare:
+        assert_allclose(
+            getattr(incpca, attribute),
+            getattr(incpca_spmd, attribute),
+            atol=tol,
+            err_msg=f"{attribute} is incorrect",
+        )
+
+    y_trans_spmd = incpca_spmd.transform(dpt_X_test)
+    y_trans = incpca.transform(dpt_X_test)
+
+    assert_allclose(_as_numpy(y_trans_spmd), _as_numpy(y_trans), atol=tol)
+
+
+@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("whiten", [True, False])
+@pytest.mark.parametrize("n_components", [None, 2, 5])
+@pytest.mark.parametrize("num_blocks", [1, 2])
+@pytest.mark.parametrize("num_samples", [200, 400])
+@pytest.mark.parametrize("num_features", [10, 20])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.mpi
+def test_incremental_pca_partial_fit_spmd_random(
+    dataframe,
+    queue,
+    whiten,
+    n_components,
+    num_blocks,
+    num_samples,
+    num_features,
+    dtype,
+):
+    # Import spmd and non-SPMD algo
+    from sklearnex.preview.decomposition import IncrementalPCA
+    from sklearnex.spmd.decomposition import IncrementalPCA as IncrementalPCA_SPMD
+
+    tol = 3e-4 if dtype == np.float32 else 1e-7
+
+    # Create data and process into dpt
+    X = _generate_statistic_data(num_samples, num_features, dtype)
+    dpt_X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_test = _generate_statistic_data(num_samples // 5, num_features, dtype)
+    dpt_X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
+    local_X = _get_local_tensor(X)
+    X_split = np.array_split(X, num_blocks)
+    split_local_X = np.array_split(local_X, num_blocks)
+
+    incpca_spmd = IncrementalPCA_SPMD(n_components=n_components, whiten=whiten)
+    incpca = IncrementalPCA(n_components=n_components, whiten=whiten)
+
+    for i in range(num_blocks):
+        local_dpt_X = _convert_to_dataframe(
+            split_local_X[i], sycl_queue=queue, target_df=dataframe
+        )
+        dpt_X = _convert_to_dataframe(X_split[i], sycl_queue=queue, target_df=dataframe)
+        incpca_spmd.partial_fit(local_dpt_X)
+        incpca.partial_fit(dpt_X)
+
+    for attribute in attributes_to_compare:
+        assert_allclose(
+            getattr(incpca, attribute),
+            getattr(incpca_spmd, attribute),
+            atol=tol,
+            err_msg=f"{attribute} is incorrect",
+        )
+
+    y_trans_spmd = incpca_spmd.transform(dpt_X_test)
+    y_trans = incpca.transform(dpt_X_test)
+
+    assert_allclose(_as_numpy(y_trans_spmd), _as_numpy(y_trans), atol=tol)