scikit-learn-intelex 2025.1.0__py312-none-manylinux_2_28_x86_64.whl

onedal/neighbors/tests/test_knn_classification.py

@@ -0,0 +1,49 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+from sklearn import datasets
+
+from onedal.neighbors import KNeighborsClassifier
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_iris(queue):
+    iris = datasets.load_iris()
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
+    assert clf.score(iris.data, iris.target, queue=queue) > 0.9
+    assert_array_equal(clf.classes_, np.sort(clf.classes_))
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_pickle(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("KNN classifier pickling for the GPU sycl_queue is buggy.")
+    iris = datasets.load_iris()
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
+    expected = clf.predict(iris.data, queue=queue)
+
+    import pickle
+
+    dump = pickle.dumps(clf)
+    clf2 = pickle.loads(dump)
+
+    assert type(clf2) == clf.__class__
+    result = clf2.predict(iris.data, queue=queue)
+    assert_array_equal(expected, result)

onedal/primitives/__init__.py

@@ -0,0 +1,27 @@
+# ==============================================================================
+# Copyright 2021 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from .get_tree import get_tree_state_cls, get_tree_state_reg
+from .kernel_functions import linear_kernel, poly_kernel, rbf_kernel, sigmoid_kernel
+
+__all__ = [
+    "get_tree_state_cls",
+    "get_tree_state_reg",
+    "linear_kernel",
+    "rbf_kernel",
+    "poly_kernel",
+    "sigmoid_kernel",
+]

onedal/primitives/get_tree.py

@@ -0,0 +1,25 @@
+# ==============================================================================
+# 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 _backend
+
+
+def get_tree_state_cls(model, iTree, n_classes):
+    return _backend.get_tree.classification.get_tree_state(model, iTree, n_classes)
+
+
+def get_tree_state_reg(model, iTree, n_classes):
+    return _backend.get_tree.regression.get_tree_state(model, iTree, n_classes)

onedal/primitives/kernel_functions.py

@@ -0,0 +1,153 @@
+# ===============================================================================
+# 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 numpy as np
+
+from onedal import _backend
+
+from ..common._policy import _get_policy
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _check_array
+
+
+def _check_inputs(X, Y):
+    def check_input(data):
+        return _check_array(data, dtype=[np.float64, np.float32], force_all_finite=False)
+
+    X = check_input(X)
+    Y = X if Y is None else check_input(Y)
+    return X, Y
+
+
+def _compute_kernel(params, submodule, X, Y, queue):
+    policy = _get_policy(queue, X, Y)
+    X, Y = _convert_to_supported(policy, X, Y)
+    params["fptype"] = "float" if X.dtype == np.float32 else "double"
+    X, Y = to_table(X, Y)
+    result = submodule.compute(policy, params, X, Y)
+    return from_table(result.values)
+
+
+def linear_kernel(X, Y=None, scale=1.0, shift=0.0, queue=None):
+    """
+    Compute the linear kernel between X and Y:
+        K(x, y) = scale*dot(x, y^T) + shift
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+    Y : ndarray of shape (n_samples_Y, n_features)
+    scale : float, default=1.0
+    shift : float, default=0.0
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+    """
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": scale, "shift": shift},
+        _backend.linear_kernel,
+        X,
+        Y,
+        queue,
+    )
+
+
+def rbf_kernel(X, Y=None, gamma=None, queue=None):
+    """
+    Compute the rbf (gaussian) kernel between X and Y:
+        K(x, y) = exp(-gamma ||x-y||^2)
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+    Y : ndarray of shape (n_samples_Y, n_features)
+    gamma : float, default=None
+        If None, defaults to 1.0 / n_features.
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+    """
+
+    X, Y = _check_inputs(X, Y)
+
+    gamma = 1.0 / X.shape[1] if gamma is None else gamma
+    sigma = np.sqrt(0.5 / gamma)
+
+    return _compute_kernel(
+        {"method": "dense", "sigma": sigma}, _backend.rbf_kernel, X, Y, queue
+    )
+
+
+def poly_kernel(X, Y=None, gamma=1.0, coef0=0.0, degree=3, queue=None):
+    """
+    Compute the poly kernel between X and Y:
+        K(x, y) = (scale*dot(x, y^T) + shift)**degree
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+    Y : ndarray of shape (n_samples_Y, n_features)
+    scale : float, default=1.0
+    shift : float, default=0.0
+    degree : float, default=3
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+    """
+
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": gamma, "shift": coef0, "degree": degree},
+        _backend.polynomial_kernel,
+        X,
+        Y,
+        queue,
+    )
+
+
+def sigmoid_kernel(X, Y=None, gamma=1.0, coef0=0.0, queue=None):
+    """
+    Compute the sigmoid kernel between X and Y:
+        K(x, y) = tanh(scale*dot(x, y^T) + shift)
+    for each pair of rows x in X and y in Y.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples_X, n_features)
+    Y : ndarray of shape (n_samples_Y, n_features)
+    scale : float, default=1.0
+    shift : float, default=0.0
+
+    Returns
+    -------
+    kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y)
+    """
+
+    X, Y = _check_inputs(X, Y)
+    return _compute_kernel(
+        {"method": "dense", "scale": gamma, "shift": coef0},
+        _backend.sigmoid_kernel,
+        X,
+        Y,
+        queue,
+    )

onedal/primitives/tests/test_kernel_functions.py

@@ -0,0 +1,159 @@
+# ==============================================================================
+# 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 numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from sklearn.metrics.pairwise import rbf_kernel as sklearn_rbf_kernel
+
+from onedal.primitives import linear_kernel, poly_kernel, rbf_kernel, sigmoid_kernel
+from onedal.tests.utils._device_selection import (
+    get_queues,
+    pass_if_not_implemented_for_gpu,
+)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_linear_kernel(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Linear kernel for the GPU sycl_queue is buggy.")
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)))
+
+    result = linear_kernel(X, queue=queue)
+    expected = np.dot(X, np.array(X).T)
+    assert_allclose(result, expected, rtol=1e-15)
+
+
+def _test_dense_small_linear_kernel(queue, scale, shift, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(5 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = linear_kernel(X, Y, scale=scale, shift=shift, queue=queue)
+    expected = np.dot(X, np.array(Y).T) * scale + shift
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-6
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("scale", [1.0, 2.0])
+@pytest.mark.parametrize("shift", [0.0, 1.0])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_linear_kernel(queue, scale, shift, dtype):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Linear kernel for the GPU sycl_queue is buggy.")
+    _test_dense_small_linear_kernel(queue, scale, shift, dtype)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_rbf_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)))
+
+    result = rbf_kernel(X, queue=queue)
+    expected = sklearn_rbf_kernel(X)
+
+    tol = 1e-5 if result.dtype == np.float32 else 1e-14
+    assert_allclose(result, expected, rtol=tol)
+
+
+def _test_dense_small_rbf_kernel(queue, gamma, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(5 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(5 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = rbf_kernel(X, Y, gamma=gamma, queue=queue)
+    expected = sklearn_rbf_kernel(X, Y, gamma)
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-5
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pytest.mark.parametrize("gamma", [0.1, None])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_small_rbf_kernel(queue, gamma, dtype):
+    _test_dense_small_rbf_kernel(queue, gamma, dtype)
+
+
+@pass_if_not_implemented_for_gpu(reason="poly kernel is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_poly_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)))
+
+    degree = 2
+    result = poly_kernel(X, degree=degree, queue=queue)
+    expected = np.dot(X, np.array(X).T) ** degree
+
+    assert_allclose(result, expected, rtol=1e-14)
+
+
+def _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(2 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = poly_kernel(X, Y, gamma=gamma, coef0=coef0, degree=degree, queue=queue)
+    expected = (gamma * np.dot(X, np.array(Y).T) + coef0) ** degree
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-5
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pass_if_not_implemented_for_gpu(reason="poly kernel is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", [0.1, 1.0])
+@pytest.mark.parametrize("coef0", [0.0, 1.0])
+@pytest.mark.parametrize("degree", [2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype):
+    _test_dense_small_poly_kernel(queue, gamma, coef0, degree, dtype)
+
+
+@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+def test_dense_self_sigmoid_kernel(queue):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((15, 4)))
+
+    result = sigmoid_kernel(X, queue=queue)
+    expected = np.tanh(np.dot(X, np.array(X).T))
+
+    assert_allclose(result, expected)
+
+
+def _test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype):
+    rng = np.random.RandomState(0)
+    X = np.array(2 * rng.random_sample((10, 4)), dtype=dtype)
+    Y = np.array(2 * rng.random_sample((15, 4)), dtype=dtype)
+
+    result = sigmoid_kernel(X, Y, gamma=gamma, coef0=coef0, queue=queue)
+    expected = np.tanh(gamma * np.dot(X, np.array(Y).T) + coef0)
+
+    tol = 1e-14 if result.dtype == np.float64 else 1e-6
+    assert_allclose(result, expected, rtol=tol)
+
+
+@pass_if_not_implemented_for_gpu(reason="sigmoid kernel is not implemented")
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("gamma", [0.1, 1.0, 2.4])
+@pytest.mark.parametrize("coef0", [0.0, 1.0, 5.5])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype):
+    _test_dense_small_sigmoid_kernel(queue, gamma, coef0, dtype)

onedal/spmd/__init__.py

@@ -0,0 +1,25 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+__all__ = [
+    "basic_statistics",
+    "cluster",
+    "covariance",
+    "decomposition",
+    "ensemble",
+    "linear_model",
+    "neighbors",
+]

onedal/spmd/_base.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 abc import ABC
+
+from onedal import _spmd_backend
+
+from ..common._base import _get_backend
+from ..common._spmd_policy import _get_spmd_policy
+
+
+class BaseEstimatorSPMD(ABC):
+    def _get_backend(self, module, submodule=None, method=None, *args, **kwargs):
+        return _get_backend(_spmd_backend, module, submodule, method, *args, **kwargs)
+
+    def _get_policy(self, queue, *data):
+        return _get_spmd_policy(queue)

onedal/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"]

onedal/spmd/basic_statistics/basic_statistics.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.basic_statistics import BasicStatistics as BasicStatistics_Batch
+
+from ..._device_offload import support_input_format
+from .._base import BaseEstimatorSPMD
+
+
+class BasicStatistics(BaseEstimatorSPMD, BasicStatistics_Batch):
+    @support_input_format()
+    def compute(self, data, weights=None, queue=None):
+        return super().compute(data, weights=weights, queue=queue)
+
+    @support_input_format()
+    def fit(self, data, sample_weight=None, queue=None):
+        return super().fit(data, sample_weight=sample_weight, queue=queue)

onedal/spmd/basic_statistics/incremental_basic_statistics.py

@@ -0,0 +1,69 @@
+# ==============================================================================
+# 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 daal4py.sklearn._utils import get_dtype
+
+from ...basic_statistics import (
+    IncrementalBasicStatistics as base_IncrementalBasicStatistics,
+)
+from ...datatypes import _convert_to_supported, to_table
+from .._base import BaseEstimatorSPMD
+
+
+class IncrementalBasicStatistics(BaseEstimatorSPMD, base_IncrementalBasicStatistics):
+    def _reset(self):
+        self._partial_result = super(base_IncrementalBasicStatistics, self)._get_backend(
+            "basic_statistics", None, "partial_compute_result"
+        )
+
+    def partial_fit(self, X, weights=None, queue=None):
+        """
+        Computes partial data for basic statistics
+        from data batch X and saves it to `_partial_result`.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data batch, where `n_samples` is the number of samples
+            in the batch, and `n_features` is the number of features.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._queue = queue
+        policy = super(base_IncrementalBasicStatistics, self)._get_policy(queue, X)
+        X, weights = _convert_to_supported(policy, X, weights)
+
+        if not hasattr(self, "_onedal_params"):
+            dtype = get_dtype(X)
+            self._onedal_params = self._get_onedal_params(False, dtype=dtype)
+
+        X_table, weights_table = to_table(X, weights)
+        self._partial_result = super(base_IncrementalBasicStatistics, self)._get_backend(
+            "basic_statistics",
+            None,
+            "partial_compute",
+            policy,
+            self._onedal_params,
+            self._partial_result,
+            X_table,
+            weights_table,
+        )

onedal/spmd/cluster/__init__.py

@@ -0,0 +1,28 @@
+# ==============================================================================
+# 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 daal4py.sklearn._utils import daal_check_version
+
+from .dbscan import DBSCAN
+
+if daal_check_version((2023, "P", 200)):
+    from .kmeans import KMeans
+
+    __all__ = ["DBSCAN", "KMeans"]
+else:
+    __all__ = [
+        "DBSCAN",
+    ]

onedal/spmd/cluster/dbscan.py

@@ -0,0 +1,23 @@
+# ==============================================================================
+# 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.cluster import DBSCAN as DBSCAN_Batch
+
+from .._base import BaseEstimatorSPMD
+
+
+class DBSCAN(BaseEstimatorSPMD, DBSCAN_Batch):
+    pass