scikit-learn-intelex 2025.7.0__py311-none-win_amd64.whl → 2025.9.0__py311-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_incremental_covariance_spmd.py

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -191,5 +192,9 @@ def test_incremental_covariance_partial_fit_spmd_synthetic(
 
     tol = 1e-7
 
-    assert_allclose(inccov_spmd.covariance_, inccov.covariance_, atol=tol)
-    assert_allclose(inccov_spmd.location_, inccov.location_, atol=tol)
+    assert_allclose(
+        _as_numpy(inccov_spmd.covariance_), _as_numpy(inccov.covariance_), atol=tol
+    )
+    assert_allclose(
+        _as_numpy(inccov_spmd.location_), _as_numpy(inccov.location_), atol=tol
+    )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/pca.py

@@ -14,8 +14,10 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.spmd.decomposition import PCA
+from onedal.spmd.decomposition import PCA as onedal_PCA
 
-# TODO:
-# Currently it uses `onedal` module interface.
-# Add sklearnex dispatching.
+from ...decomposition import PCA as base_PCA
+
+
+class PCA(base_PCA):
+    _onedal_PCA = staticmethod(onedal_PCA)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_incremental_pca_spmd.py

@@ -262,8 +262,8 @@ def test_incremental_pca_partial_fit_spmd_random(
 
     for attribute in attributes_to_compare:
         assert_allclose(
-            getattr(incpca, attribute),
-            getattr(incpca_spmd, attribute),
+            _as_numpy(getattr(incpca, attribute)),
+            _as_numpy(getattr(incpca_spmd, attribute)),
             atol=tol,
             err_msg=f"{attribute} is incorrect",
         )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_pca_spmd.py

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -122,12 +123,24 @@ def test_pca_spmd_synthetic(
     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_,
+        _as_numpy(spmd_result.components_),
+        _as_numpy(batch_result.components_),
+        atol=tol,
+        rtol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.singular_values_),
+        _as_numpy(batch_result.singular_values_),
+        atol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.noise_variance_),
+        _as_numpy(batch_result.noise_variance_),
+        atol=tol,
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.explained_variance_ratio_),
+        _as_numpy(batch_result.explained_variance_ratio_),
         atol=tol,
     )

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/spmd/ensemble/forest.py

@@ -0,0 +1,299 @@
+# ==============================================================================
+# 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 sklearn_check_version
+from onedal.spmd.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
+from onedal.spmd.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
+
+from ...ensemble import RandomForestClassifier as RandomForestClassifier_Batch
+from ...ensemble import RandomForestRegressor as RandomForestRegressor_Batch
+
+
+def local_trees_wrapper(factor_cls, local_trees_mode):
+    class WrappedFactory(factor_cls):
+        def __init__(self, *args, **params):
+            params["local_trees_mode"] = local_trees_mode
+            super().__init__(*args, **params)
+
+    return WrappedFactory
+
+
+class RandomForestClassifier(RandomForestClassifier_Batch):
+    __doc__ = RandomForestClassifier_Batch.__doc__
+    _onedal_factory_cls = onedal_RandomForestClassifier
+
+    # Wrap _onedal_factory to support local_trees_mode parameter
+    @property
+    def _onedal_factory(self):
+        return local_trees_wrapper(self._onedal_factory_cls, self.local_trees_mode)
+
+    # Init constructor with local_trees_mode parameter but pass to parent
+    # class without (to maintain scikit-learn estimator compatibility)
+    if sklearn_check_version("1.4"):
+
+        def __init__(
+            self,
+            n_estimators=100,
+            *,
+            criterion="gini",
+            max_depth=None,
+            min_samples_split=2,
+            min_samples_leaf=1,
+            min_weight_fraction_leaf=0.0,
+            max_features="sqrt",
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            bootstrap=True,
+            oob_score=False,
+            n_jobs=None,
+            random_state=None,
+            verbose=0,
+            warm_start=False,
+            class_weight=None,
+            ccp_alpha=0.0,
+            max_samples=None,
+            monotonic_cst=None,
+            max_bins=256,
+            min_bin_size=1,
+            local_trees_mode=False,
+        ):
+            self.local_trees_mode = local_trees_mode
+            super().__init__(
+                n_estimators=n_estimators,
+                criterion=criterion,
+                max_depth=max_depth,
+                min_samples_split=min_samples_split,
+                min_samples_leaf=min_samples_leaf,
+                min_weight_fraction_leaf=min_weight_fraction_leaf,
+                max_features=max_features,
+                max_leaf_nodes=max_leaf_nodes,
+                min_impurity_decrease=min_impurity_decrease,
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                ccp_alpha=ccp_alpha,
+                max_samples=max_samples,
+                monotonic_cst=monotonic_cst,
+                max_bins=max_bins,
+                min_bin_size=min_bin_size,
+            )
+
+    else:
+
+        def __init__(
+            self,
+            n_estimators=100,
+            *,
+            criterion="gini",
+            max_depth=None,
+            min_samples_split=2,
+            min_samples_leaf=1,
+            min_weight_fraction_leaf=0.0,
+            max_features="sqrt" if sklearn_check_version("1.1") else "auto",
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            bootstrap=True,
+            oob_score=False,
+            n_jobs=None,
+            random_state=None,
+            verbose=0,
+            warm_start=False,
+            class_weight=None,
+            ccp_alpha=0.0,
+            max_samples=None,
+            max_bins=256,
+            min_bin_size=1,
+            local_trees_mode=False,
+        ):
+            self.local_trees_mode = local_trees_mode
+            super().__init__(
+                n_estimators=n_estimators,
+                criterion=criterion,
+                max_depth=max_depth,
+                min_samples_split=min_samples_split,
+                min_samples_leaf=min_samples_leaf,
+                min_weight_fraction_leaf=min_weight_fraction_leaf,
+                max_features=max_features,
+                max_leaf_nodes=max_leaf_nodes,
+                min_impurity_decrease=min_impurity_decrease,
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                ccp_alpha=ccp_alpha,
+                max_samples=max_samples,
+                max_bins=max_bins,
+                min_bin_size=min_bin_size,
+            )
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        # TODO:
+        # check which methods supported SPMD interface on CPU.
+        ready = super()._onedal_cpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        ready = super()._onedal_gpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready
+
+
+class RandomForestRegressor(RandomForestRegressor_Batch):
+    __doc__ = RandomForestRegressor_Batch.__doc__
+    _onedal_factory_cls = onedal_RandomForestRegressor
+
+    # Wrap _onedal_factory to support local_trees_mode parameter
+    @property
+    def _onedal_factory(self):
+        return local_trees_wrapper(self._onedal_factory_cls, self.local_trees_mode)
+
+    # Init constructor with local_trees_mode parameter but pass to parent
+    # class without (to maintain scikit-learn estimator compatibility)
+    if sklearn_check_version("1.4"):
+
+        def __init__(
+            self,
+            n_estimators=100,
+            *,
+            criterion="squared_error",
+            max_depth=None,
+            min_samples_split=2,
+            min_samples_leaf=1,
+            min_weight_fraction_leaf=0.0,
+            max_features=1.0,
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            bootstrap=True,
+            oob_score=False,
+            n_jobs=None,
+            random_state=None,
+            verbose=0,
+            warm_start=False,
+            ccp_alpha=0.0,
+            max_samples=None,
+            monotonic_cst=None,
+            max_bins=256,
+            min_bin_size=1,
+            local_trees_mode=False,
+        ):
+            self.local_trees_mode = local_trees_mode
+            super().__init__(
+                n_estimators=n_estimators,
+                criterion=criterion,
+                max_depth=max_depth,
+                min_samples_split=min_samples_split,
+                min_samples_leaf=min_samples_leaf,
+                min_weight_fraction_leaf=min_weight_fraction_leaf,
+                max_features=max_features,
+                max_leaf_nodes=max_leaf_nodes,
+                min_impurity_decrease=min_impurity_decrease,
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                ccp_alpha=ccp_alpha,
+                max_samples=max_samples,
+                monotonic_cst=monotonic_cst,
+                max_bins=max_bins,
+                min_bin_size=min_bin_size,
+            )
+
+    else:
+
+        def __init__(
+            self,
+            n_estimators=100,
+            *,
+            criterion="squared_error",
+            max_depth=None,
+            min_samples_split=2,
+            min_samples_leaf=1,
+            min_weight_fraction_leaf=0.0,
+            max_features=1.0 if sklearn_check_version("1.1") else "auto",
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            bootstrap=True,
+            oob_score=False,
+            n_jobs=None,
+            random_state=None,
+            verbose=0,
+            warm_start=False,
+            ccp_alpha=0.0,
+            max_samples=None,
+            max_bins=256,
+            min_bin_size=1,
+            local_trees_mode=False,
+        ):
+            self.local_trees_mode = local_trees_mode
+            super().__init__(
+                n_estimators=n_estimators,
+                criterion=criterion,
+                max_depth=max_depth,
+                min_samples_split=min_samples_split,
+                min_samples_leaf=min_samples_leaf,
+                min_weight_fraction_leaf=min_weight_fraction_leaf,
+                max_features=max_features,
+                max_leaf_nodes=max_leaf_nodes,
+                min_impurity_decrease=min_impurity_decrease,
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                ccp_alpha=ccp_alpha,
+                max_samples=max_samples,
+                max_bins=max_bins,
+                min_bin_size=min_bin_size,
+            )
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        # TODO:
+        # check which methods supported SPMD interface on CPU.
+        ready = super()._onedal_cpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        ready = super()._onedal_gpu_supported(method_name, *data)
+        if not ready:
+            raise RuntimeError(
+                f"Method {method_name} in {self.__class__.__name__} "
+                "is not supported with given inputs."
+            )
+        return ready

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/ensemble/tests/test_forest_spmd.py

@@ -104,6 +104,7 @@ def test_rfcls_spmd_gold(dataframe, queue):
 @pytest.mark.parametrize("n_features_and_classes", [(5, 2), (25, 2), (25, 10)])
 @pytest.mark.parametrize("n_estimators", [10, 100])
 @pytest.mark.parametrize("max_depth", [3, None])
+@pytest.mark.parametrize("local_trees_mode", [False, True])
 @pytest.mark.parametrize(
     "dataframe,queue",
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
@@ -116,6 +117,7 @@ def test_rfcls_spmd_synthetic(
     n_features_and_classes,
     n_estimators,
     max_depth,
+    local_trees_mode,
     dataframe,
     queue,
     dtype,
@@ -145,7 +147,10 @@ def test_rfcls_spmd_synthetic(
 
     # Ensure predictions of batch algo match spmd
     spmd_model = RandomForestClassifier_SPMD(
-        n_estimators=n_estimators, max_depth=max_depth, random_state=0
+        n_estimators=n_estimators,
+        max_depth=max_depth,
+        local_trees_mode=local_trees_mode,
+        random_state=0,
     )
     # Configure raw input status for spmd estimator
     with config_context(use_raw_input=use_raw_input):
@@ -234,6 +239,7 @@ def test_rfreg_spmd_gold(dataframe, queue):
 @pytest.mark.parametrize("n_features", [5, 25])
 @pytest.mark.parametrize("n_estimators", [10, 100])
 @pytest.mark.parametrize("max_depth", [3, None])
+@pytest.mark.parametrize("local_trees_mode", [False, True])
 @pytest.mark.parametrize(
     "dataframe,queue",
     get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
@@ -242,7 +248,15 @@ def test_rfreg_spmd_gold(dataframe, queue):
 @pytest.mark.parametrize("use_raw_input", [True, False])
 @pytest.mark.mpi
 def test_rfreg_spmd_synthetic(
-    n_samples, n_features, n_estimators, max_depth, dataframe, queue, dtype, use_raw_input
+    n_samples,
+    n_features,
+    n_estimators,
+    max_depth,
+    local_trees_mode,
+    dataframe,
+    queue,
+    dtype,
+    use_raw_input,
 ):
     # Import spmd and batch algo
     from sklearnex.ensemble import RandomForestRegressor as RandomForestRegressor_Batch
@@ -267,8 +281,11 @@ def test_rfreg_spmd_synthetic(
 
     # Ensure predictions of batch algo match spmd
     with config_context(use_raw_input=use_raw_input):
-        spmd_model = RandomForestRegressor_Batch(
-            n_estimators=n_estimators, max_depth=max_depth, random_state=0
+        spmd_model = RandomForestRegressor_SPMD(
+            n_estimators=n_estimators,
+            max_depth=max_depth,
+            local_trees_mode=local_trees_mode,
+            random_state=0,
         ).fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = RandomForestRegressor_Batch(
         n_estimators=n_estimators, max_depth=max_depth, random_state=0

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/linear_model.py

@@ -14,8 +14,11 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.spmd.linear_model import LinearRegression
+from onedal.spmd.linear_model import LinearRegression as onedal_LinearRegression
 
-# TODO:
-# Currently it uses `onedal` module interface.
-# Add sklearnex dispatching.
+from ...linear_model import LinearRegression as LinearRegression_Batch
+
+
+class LinearRegression(LinearRegression_Batch):
+    __doc__ = LinearRegression_Batch.__doc__
+    _onedal_LinearRegression = staticmethod(onedal_LinearRegression)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_incremental_linear_spmd.py

@@ -99,9 +99,11 @@ def test_incremental_linear_regression_fit_spmd_gold(
     inclin.fit(dpt_X, dpt_y)
 
     rtol = 1e-5 if (dtype == np.float32) else 1e-7
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, rtol=rtol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), rtol=rtol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, rtol=rtol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), rtol=rtol
+        )
 
 
 @pytest.mark.skipif(
@@ -184,9 +186,11 @@ def test_incremental_linear_regression_partial_fit_spmd_gold(
     inclin.fit(dpt_X, dpt_y)
 
     rtol = 1e-5 if (dtype == np.float32) else 1e-7
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, rtol=rtol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), rtol=rtol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, rtol=rtol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), rtol=rtol
+        )
 
 
 @pytest.mark.skipif(
@@ -242,9 +246,11 @@ def test_incremental_linear_regression_fit_spmd_random(
     inclin_spmd.fit(local_dpt_X, local_dpt_y)
     inclin.fit(dpt_X, dpt_y)
 
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), atol=tol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), atol=tol
+        )
 
     y_pred_spmd = inclin_spmd.predict(dpt_X_test)
     y_pred = inclin.predict(dpt_X_test)
@@ -325,9 +331,11 @@ def test_incremental_linear_regression_partial_fit_spmd_random(
         inclin_spmd.partial_fit(local_dpt_X, local_dpt_y)
         inclin.partial_fit(dpt_X, dpt_y)
 
-    assert_allclose(inclin.coef_, inclin_spmd.coef_, atol=tol)
+    assert_allclose(_as_numpy(inclin.coef_), _as_numpy(inclin_spmd.coef_), atol=tol)
     if fit_intercept:
-        assert_allclose(inclin.intercept_, inclin_spmd.intercept_, atol=tol)
+        assert_allclose(
+            _as_numpy(inclin.intercept_), _as_numpy(inclin_spmd.intercept_), atol=tol
+        )
 
     y_pred_spmd = inclin_spmd.predict(dpt_X_test)
     y_pred = inclin.predict(dpt_X_test)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/spmd/linear_model/tests/test_linear_regression_spmd.py

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -83,8 +84,8 @@ def test_linear_spmd_gold(dataframe, queue):
     spmd_model = LinearRegression_SPMD().fit(local_dpt_X_train, local_dpt_y_train)
     batch_model = LinearRegression_Batch().fit(X_train, y_train)
 
-    assert_allclose(spmd_model.coef_, batch_model.coef_)
-    assert_allclose(spmd_model.intercept_, batch_model.intercept_)
+    assert_allclose(_as_numpy(spmd_model.coef_), _as_numpy(batch_model.coef_))
+    assert_allclose(_as_numpy(spmd_model.intercept_), _as_numpy(batch_model.intercept_))
 
     # ensure predictions of batch algo match spmd
     spmd_result = spmd_model.predict(local_dpt_X_test)
@@ -142,8 +143,15 @@ def test_linear_spmd_synthetic(
     batch_model = LinearRegression_Batch().fit(X_train, y_train)
 
     tol = 1e-3 if dtype == np.float32 else 1e-7
-    assert_allclose(spmd_model.coef_, batch_model.coef_, rtol=tol, atol=tol)
-    assert_allclose(spmd_model.intercept_, batch_model.intercept_, rtol=tol, atol=tol)
+    assert_allclose(
+        _as_numpy(spmd_model.coef_), _as_numpy(batch_model.coef_), rtol=tol, atol=tol
+    )
+    assert_allclose(
+        _as_numpy(spmd_model.intercept_),
+        _as_numpy(batch_model.intercept_),
+        rtol=tol,
+        atol=tol,
+    )
 
     # ensure predictions of batch algo match spmd
     # Configure raw input status for spmd estimator

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/spmd/neighbors/__init__.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.spmd.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+    NearestNeighbors,
+)
+
+__all__ = ["KNeighborsClassifier", "KNeighborsRegressor", "NearestNeighbors"]