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

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/cluster/kmeans_init.py

@@ -0,0 +1,115 @@
+# ==============================================================================
+# 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
+from scipy.sparse import issparse
+from sklearn.utils import check_random_state
+
+from daal4py.sklearn._utils import daal_check_version, get_dtype
+
+from ..common._base import BaseEstimator as onedal_BaseEstimator
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _check_array
+
+if daal_check_version((2023, "P", 200)):
+
+    class KMeansInit(onedal_BaseEstimator):
+        """
+        KMeansInit oneDAL implementation.
+        """
+
+        def __init__(
+            self,
+            cluster_count,
+            seed=777,
+            local_trials_count=None,
+            algorithm="plus_plus_dense",
+        ):
+            self.cluster_count = cluster_count
+            self.seed = seed
+            self.local_trials_count = local_trials_count
+            self.algorithm = algorithm
+
+            if local_trials_count is None:
+                self.local_trials_count = 2 + int(np.log(cluster_count))
+            else:
+                self.local_trials_count = local_trials_count
+
+        def _get_onedal_params(self, dtype=np.float32):
+            return {
+                "fptype": "float" if dtype == np.float32 else "double",
+                "local_trials_count": self.local_trials_count,
+                "method": self.algorithm,
+                "seed": self.seed,
+                "cluster_count": self.cluster_count,
+            }
+
+        def _get_params_and_input(self, X, policy):
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                accept_sparse="csr",
+                force_all_finite=False,
+            )
+
+            X = _convert_to_supported(policy, X)
+
+            dtype = get_dtype(X)
+            params = self._get_onedal_params(dtype)
+            return (params, to_table(X), dtype)
+
+        def _compute_raw(self, X_table, module, policy, dtype=np.float32):
+            params = self._get_onedal_params(dtype)
+
+            result = module.compute(policy, params, X_table)
+
+            return result.centroids
+
+        def _compute(self, X, module, queue):
+            policy = self._get_policy(queue, X)
+            # oneDAL KMeans Init for sparse data does not have GPU support
+            if issparse(X):
+                policy = self._get_policy(None, None)
+            _, X_table, dtype = self._get_params_and_input(X, policy)
+
+            centroids = self._compute_raw(X_table, module, policy, dtype)
+
+            return from_table(centroids)
+
+        def compute_raw(self, X_table, policy, dtype=np.float32):
+            return self._compute_raw(
+                X_table, self._get_backend("kmeans_init", "init", None), policy, dtype
+            )
+
+        def compute(self, X, queue=None):
+            return self._compute(X, self._get_backend("kmeans_init", "init", None), queue)
+
+    def kmeans_plusplus(
+        X,
+        n_clusters,
+        *,
+        x_squared_norms=None,
+        random_state=None,
+        n_local_trials=None,
+        queue=None,
+    ):
+        random_seed = check_random_state(random_state).tomaxint()
+        return (
+            KMeansInit(
+                n_clusters, seed=random_seed, local_trials_count=n_local_trials
+            ).compute(X, queue),
+            np.full(n_clusters, -1),
+        )

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/cluster/tests/test_dbscan.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.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from sklearn.cluster import DBSCAN as DBSCAN_SKLEARN
+from sklearn.cluster.tests.common import generate_clustered_data
+
+from onedal.cluster import DBSCAN as ONEDAL_DBSCAN
+from onedal.tests.utils._device_selection import get_queues
+
+
+def generate_data(
+    low: int, high: int, samples_number: int, sample_dimension: tuple
+) -> tuple:
+    generator = np.random.RandomState()
+    table_size = (samples_number, sample_dimension)
+    return generator.uniform(low=low, high=high, size=table_size), generator.uniform(
+        size=samples_number
+    )
+
+
+def check_labels_equals(left_labels: np.ndarray, right_labels: np.ndarray) -> bool:
+    if left_labels.shape != right_labels.shape:
+        raise Exception("Shapes not equal")
+    if len(left_labels.shape) != 1:
+        raise Exception("Shapes size not equals 1")
+    if len(set(left_labels)) != len(set(right_labels)):
+        raise Exception("Cluster counts not equal")
+    dict_checker = {}
+    for index_sample in range(left_labels.shape[0]):
+        if left_labels[index_sample] not in dict_checker:
+            dict_checker[left_labels[index_sample]] = right_labels[index_sample]
+        elif dict_checker[left_labels[index_sample]] != right_labels[index_sample]:
+            raise Exception("Wrong clustering")
+    return True
+
+
+def _test_dbscan_big_data_numpy_gen(
+    queue,
+    eps: float,
+    min_samples: int,
+    metric: str,
+    use_weights: bool,
+    low=-100.0,
+    high=100.0,
+    samples_number=1000,
+    sample_dimension=4,
+):
+    data, weights = generate_data(
+        low=low,
+        high=high,
+        samples_number=samples_number,
+        sample_dimension=sample_dimension,
+    )
+    if use_weights is False:
+        weights = None
+    initialized_daal_dbscan = ONEDAL_DBSCAN(
+        eps=eps, min_samples=min_samples, metric=metric
+    ).fit(X=data, sample_weight=weights, queue=queue)
+    initialized_sklearn_dbscan = DBSCAN_SKLEARN(
+        metric=metric, eps=eps, min_samples=min_samples
+    ).fit(X=data, sample_weight=weights)
+    check_labels_equals(
+        initialized_daal_dbscan.labels_, initialized_sklearn_dbscan.labels_
+    )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_dbscan_big_data_numpy_gen(queue, metric, use_weights: bool):
+    eps = 35.0
+    min_samples = 6
+    _test_dbscan_big_data_numpy_gen(
+        queue, eps=eps, min_samples=min_samples, metric=metric, use_weights=use_weights
+    )
+
+
+def _test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    eps_begin = 0.05
+    eps_end = 0.5
+    eps_step = 0.05
+    min_samples_begin = 5
+    min_samples_end = 15
+    min_samples_step = 1
+    for eps in np.arange(eps_begin, eps_end, eps_step):
+        for min_samples in range(min_samples_begin, min_samples_end, min_samples_step):
+            _test_dbscan_big_data_numpy_gen(
+                queue,
+                eps=eps,
+                min_samples=min_samples,
+                metric=metric,
+                use_weights=use_weights,
+            )
+
+
+@pytest.mark.parametrize(
+    "metric",
+    [
+        "euclidean",
+    ],
+)
+@pytest.mark.parametrize("use_weights", [True, False])
+@pytest.mark.parametrize("queue", get_queues())
+def test_across_grid_parameter_numpy_gen(queue, metric, use_weights: bool):
+    _test_across_grid_parameter_numpy_gen(queue, metric=metric, use_weights=use_weights)

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/cluster/tests/test_kmeans.py

@@ -0,0 +1,88 @@
+# ==============================================================================
+# 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_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.cluster import kmeans_plusplus as init_external
+    from sklearn.neighbors import NearestNeighbors
+
+    from onedal.cluster import KMeans
+    from onedal.cluster import kmeans_plusplus as init_internal
+    from onedal.tests.utils._device_selection import get_queues
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 4, 17, 24])
+    @pytest.mark.parametrize("n_cluster", [9, 11, 32])
+    @pytest.mark.parametrize("pipeline", ["implicit", "external", "internal"])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster, pipeline):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        if pipeline == "external":
+            init_data, _ = init_external(X, n_cluster)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        elif pipeline == "internal":
+            init_data, _ = init_internal(X, n_cluster, queue=queue)
+            m = KMeans(n_cluster, init=init_data, max_iter=5)
+        else:
+            m = KMeans(n_cluster, init="k-means++", max_iter=5)
+
+        m.fit(X, queue=queue)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 3 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        # TODO: investigate accuracy with kmeans++ init and remove - 1
+        assert desired_accuracy - 1 <= exp_accuracy

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/cluster/tests/test_kmeans_init.py

@@ -0,0 +1,93 @@
+# ===============================================================================
+# 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_array_equal
+
+from daal4py.sklearn._utils import daal_check_version
+
+if daal_check_version((2023, "P", 200)):
+    from sklearn.datasets import load_breast_cancer
+    from sklearn.metrics import davies_bouldin_score
+
+    from onedal.cluster import KMeans, kmeans_plusplus
+    from onedal.tests.utils._device_selection import get_queues
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_cluster", [2, 5, 11, 128])
+    def test_breast_cancer(queue, dtype, n_cluster):
+        X, _ = load_breast_cancer(return_X_y=True)
+        X = np.asarray(X).astype(dtype=dtype)
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=777, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=1)
+        res = davies_bouldin_score(X, m.fit(X).predict(X))
+        thr = 0.45 if n_cluster < 20 else 0.55
+        assert res > thr
+
+    from sklearn.neighbors import NearestNeighbors
+
+    def generate_dataset(n_dim, n_cluster, n_points=None, seed=777, dtype=np.float32):
+        # We need some reference value of points for each cluster
+        n_points = (n_dim * n_cluster) if n_points is None else n_points
+
+        # Creating generator and generating cluster points
+        gen = np.random.Generator(np.random.MT19937(seed))
+        cs = gen.uniform(low=-1.0, high=+1.0, size=(n_cluster, n_dim))
+
+        # Finding variances for each cluster using 3 sigma criteria
+        # It ensures that point is in the Voronoi cell of cluster
+        nn = NearestNeighbors(n_neighbors=2)
+        d, i = nn.fit(cs).kneighbors(cs)
+        assert_array_equal(i[:, 0], np.arange(n_cluster))
+        vs = d[:, 1] / 3
+
+        # Generating dataset
+        def gen_one(c):
+            params = {"loc": cs[c, :], "scale": vs[c], "size": (n_points, n_dim)}
+            return gen.normal(**params)
+
+        data = [gen_one(c) for c in range(n_cluster)]
+        data = np.concatenate(data, axis=0)
+        gen.shuffle(data, axis=0)
+
+        data = data.astype(dtype)
+
+        return (cs, vs, data)
+
+    @pytest.mark.parametrize("queue", get_queues())
+    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
+    @pytest.mark.parametrize("n_dim", [3, 12, 17])
+    @pytest.mark.parametrize("n_cluster", [2, 15, 61])
+    def test_generated_dataset(queue, dtype, n_dim, n_cluster):
+        seed = 777 * n_dim * n_cluster
+        cs, vs, X = generate_dataset(n_dim, n_cluster, seed=seed, dtype=dtype)
+
+        init_data, _ = kmeans_plusplus(X, n_cluster, random_state=seed, queue=queue)
+        m = KMeans(n_cluster, init=init_data, max_iter=3, algorithm="lloyd").fit(X)
+
+        rs_centroids = m.cluster_centers_
+        nn = NearestNeighbors(n_neighbors=1)
+        d, i = nn.fit(rs_centroids).kneighbors(cs)
+        # We have applied 2 sigma rule once
+        desired_accuracy = int(0.9973 * n_cluster)
+        if d.dtype == np.float64:
+            desired_accuracy = desired_accuracy - 1
+        correctness = d.reshape(-1) <= (vs * 3)
+        exp_accuracy = np.count_nonzero(correctness)
+
+        assert desired_accuracy <= exp_accuracy

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/common/_base.py

@@ -0,0 +1,38 @@
+# ==============================================================================
+# 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 abc import ABC
+
+from onedal import _backend
+
+from ._policy import _get_policy
+
+
+def _get_backend(backend, module, submodule=None, method=None, *args, **kwargs):
+    result = getattr(backend, module)
+    if submodule:
+        result = getattr(result, submodule)
+    if method:
+        return getattr(result, method)(*args, **kwargs)
+    return result
+
+
+class BaseEstimator(ABC):
+    def _get_backend(self, module, submodule=None, method=None, *args, **kwargs):
+        return _get_backend(_backend, module, submodule, method, *args, **kwargs)
+
+    def _get_policy(self, queue, *data):
+        return _get_policy(queue, *data)

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/common/_estimator_checks.py

@@ -0,0 +1,47 @@
+# ===============================================================================
+# Copyright 2022 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.
+# ===============================================================================
+
+
+def _check_is_fitted(estimator, attributes=None, *, msg=None):
+    if msg is None:
+        msg = (
+            "This %(name)s instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using this estimator."
+        )
+
+    if not (
+        hasattr(estimator, "fit")
+        or (hasattr(estimator, "partial_fit") and hasattr(estimator, "finalize_fit"))
+    ):
+        raise TypeError("%s is not an estimator instance." % (estimator))
+
+    if attributes is not None:
+        if not isinstance(attributes, (list, tuple)):
+            attributes = [attributes]
+        attrs = all([hasattr(estimator, attr) for attr in attributes])
+    else:
+        attrs = [v for v in vars(estimator) if v.endswith("_") and not v.startswith("__")]
+
+    if not attrs:
+        raise AttributeError(msg % {"name": type(estimator).__name__})
+
+
+def _is_classifier(estimator):
+    return getattr(estimator, "_estimator_type", None) == "classifier"
+
+
+def _is_regressor(estimator):
+    return getattr(estimator, "_estimator_type", None) == "regressor"

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/common/_mixin.py

@@ -0,0 +1,62 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+
+class ClusterMixin:
+    _estimator_type = "clusterer"
+
+    def fit_predict(self, X, y=None, queue=None, **kwargs):
+        self.fit(X, queue=queue, **kwargs)
+        return self.labels_
+
+    def _more_tags(self):
+        return {"preserves_dtype": []}
+
+
+class ClassifierMixin:
+    _estimator_type = "classifier"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import accuracy_score
+
+        return accuracy_score(
+            y, self.predict(X, queue=queue), sample_weight=sample_weight
+        )
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class RegressorMixin:
+    _estimator_type = "regressor"
+
+    def score(self, X, y, sample_weight=None, queue=None):
+        from sklearn.metrics import r2_score
+
+        return r2_score(y, self.predict(X, queue=queue), sample_weight=sample_weight)
+
+    def _more_tags(self):
+        return {"requires_y": True}
+
+
+class TransformerMixin:
+    _estimator_type = "transformer"
+
+    def fit_transform(self, X, y=None, queue=None, **fit_params):
+        if y is None:
+            return self.fit(X, queue=queue, **fit_params).transform(X, queue=queue)
+        else:
+            return self.fit(X, y, queue=queue, **fit_params).transform(X, queue=queue)

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/common/_policy.py

@@ -0,0 +1,59 @@
+# ==============================================================================
+# 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 sys
+
+from onedal import _backend, _is_dpc_backend
+
+
+def _get_policy(queue, *data):
+    data_queue = _get_queue(*data)
+    if _is_dpc_backend:
+        if queue is None:
+            if data_queue is None:
+                return _HostInteropPolicy()
+            return _DataParallelInteropPolicy(data_queue)
+        return _DataParallelInteropPolicy(queue)
+    else:
+        if not (data_queue is None and queue is None):
+            raise RuntimeError(
+                "Operation using the requested SYCL queue requires the DPC backend"
+            )
+        return _HostInteropPolicy()
+
+
+def _get_queue(*data):
+    if len(data) > 0 and hasattr(data[0], "__sycl_usm_array_interface__"):
+        # Assume that all data reside on the same device
+        return data[0].__sycl_usm_array_interface__["syclobj"]
+    return None
+
+
+class _HostInteropPolicy(_backend.host_policy):
+    def __init__(self):
+        super().__init__()
+
+
+if _is_dpc_backend:
+    from onedal._device_offload import DummySyclQueue
+
+    class _DataParallelInteropPolicy(_backend.data_parallel_policy):
+        def __init__(self, queue):
+            self._queue = queue
+            if isinstance(queue, DummySyclQueue):
+                super().__init__(self._queue.sycl_device.get_filter_string())
+                return
+            super().__init__(self._queue)

scikit_learn_intelex-2025.0.0.data/data/Lib/site-packages/onedal/common/_spmd_policy.py

@@ -0,0 +1,30 @@
+# ==============================================================================
+# 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 onedal import _is_spmd_backend
+
+if _is_spmd_backend:
+    from onedal import _spmd_backend
+
+    class _SPMDDataParallelInteropPolicy(_spmd_backend.spmd_data_parallel_policy):
+        def __init__(self, queue):
+            self._queue = queue
+            super().__init__(self._queue)
+
+    def _get_spmd_policy(queue):
+        # TODO:
+        # cases when queue is None
+        return _SPMDDataParallelInteropPolicy(queue)