scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.8.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/sklearnex/preview/covariance/tests/test_covariance.py

@@ -0,0 +1,112 @@
+# ===============================================================================
+# 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_allclose
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.preview.covariance import EmpiricalCovariance
+
+
+@pytest.fixture
+def hyperparameters(request):
+    hparams = EmpiricalCovariance.get_hyperparameters("fit")
+
+    def restore_hyperparameters():
+        EmpiricalCovariance.reset_hyperparameters("fit")
+
+    request.addfinalizer(restore_hyperparameters)
+    return hparams
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("macro_block", [None, 2])
+@pytest.mark.parametrize("grain_size", [None, 2])
+@pytest.mark.parametrize("assume_centered", [True, False])
+def test_sklearnex_import_covariance(
+    hyperparameters, dataframe, queue, macro_block, grain_size, assume_centered
+):
+    X = np.array([[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]])
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    empcov = EmpiricalCovariance(assume_centered=assume_centered)
+
+    if daal_check_version((2025, "P", 700)):
+        if macro_block is not None:
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+            hyperparameters.cpu_macro_block = macro_block
+        if grain_size is not None:
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+            hyperparameters.cpu_grain_size = grain_size
+
+    result = empcov.fit(X)
+
+    expected_covariance = np.array([[0, 0], [0, 0]])
+    expected_means = np.array([0, 0])
+
+    if assume_centered:
+        expected_covariance = np.array([[0, 0], [0, 1]])
+    else:
+        expected_means = np.array([0, 1])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)
+
+    X = np.array([[1, 2], [3, 6]])
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    result = empcov.fit(X)
+
+    if assume_centered:
+        expected_covariance = np.array([[5, 10], [10, 20]])
+    else:
+        expected_covariance = np.array([[1, 2], [2, 4]])
+        expected_means = np.array([2, 4])
+
+    assert_allclose(expected_covariance, result.covariance_)
+    assert_allclose(expected_means, result.location_)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 700)),
+    reason="Functionality introduced in a later version",
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("assume_centered", [True, False])
+def test_non_batched_covariance(hyperparameters, dataframe, queue, assume_centered):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Test for CPU-only functionality")
+
+    from sklearnex.preview.covariance import EmpiricalCovariance
+
+    X = np.random.default_rng(seed=123).random(size=(20, 5))
+
+    hyperparameters.cpu_max_cols_batched = np.iinfo(np.int32).max
+    res_batched = EmpiricalCovariance(assume_centered=assume_centered).fit(X).covariance_
+
+    hyperparameters.cpu_max_cols_batched = 1
+    res_non_batched = (
+        EmpiricalCovariance(assume_centered=assume_centered).fit(X).covariance_
+    )
+
+    np.testing.assert_allclose(res_non_batched, res_batched)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/basic_statistics.py

@@ -14,8 +14,11 @@
 # limitations under the License.
 # ==============================================================================
 
-from onedal.spmd.basic_statistics import BasicStatistics
+from onedal.spmd.basic_statistics import BasicStatistics as onedal_BasicStatistics
 
-# TODO:
-# Currently it uses `onedal` module interface.
-# Add sklearnex dispatching.
+from ...basic_statistics import BasicStatistics as BasicStatistics_Batch
+
+
+class BasicStatistics(BasicStatistics_Batch):
+    __doc__ = BasicStatistics_Batch.__doc__
+    _onedal_basic_statistics = staticmethod(onedal_BasicStatistics)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_basic_statistics_spmd.py

@@ -20,6 +20,7 @@ from numpy.testing import assert_allclose
 
 from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -68,7 +69,8 @@ def test_basic_stats_spmd_gold(dataframe, queue):
     batch_result = BasicStatistics_Batch().fit(data)
 
     for option in options_and_tests:
-        assert_allclose(getattr(spmd_result, option), getattr(batch_result, option))
+        attr = option + "_"
+        assert_allclose(getattr(spmd_result, attr), getattr(batch_result, attr))
 
 
 @pytest.mark.skipif(
@@ -106,9 +108,10 @@ def test_basic_stats_spmd_synthetic(
 
     tol = 1e-5 if dtype == np.float32 else 1e-7
     for option in options_and_tests:
+        attr = option + "_"
         assert_allclose(
-            getattr(spmd_result, option),
-            getattr(batch_result, option),
+            _as_numpy(getattr(spmd_result, attr)),
+            _as_numpy(getattr(batch_result, attr)),
             atol=tol,
             rtol=tol,
         )

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/basic_statistics/tests/test_incremental_basic_statistics_spmd.py

@@ -20,6 +20,7 @@ from numpy.testing import assert_allclose
 
 from onedal.basic_statistics.tests.utils import options_and_tests
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -89,9 +90,10 @@ def test_incremental_basic_statistics_fit_spmd_gold(dataframe, queue, weighted,
     )
 
     for option in options_and_tests:
+        attr = option + "_"
         assert_allclose(
-            getattr(incbs_spmd, option),
-            getattr(incbs, option),
+            getattr(incbs_spmd, attr),
+            getattr(incbs, attr),
             err_msg=f"Result for {option} is incorrect",
         )
 
@@ -162,9 +164,10 @@ def test_incremental_basic_statistics_partial_fit_spmd_gold(
     incbs.fit(dpt_data, sample_weight=dpt_weights if weighted else None)
 
     for option in options_and_tests:
+        attr = option + "_"
         assert_allclose(
-            getattr(incbs_spmd, option),
-            getattr(incbs, option),
+            getattr(incbs_spmd, attr),
+            getattr(incbs, attr),
             err_msg=f"Result for {option} is incorrect",
         )
 
@@ -234,8 +237,8 @@ def test_incremental_basic_statistics_single_option_partial_fit_spmd_gold(
         )
 
     incbs.fit(dpt_data, sample_weight=dpt_weights if weighted else None)
-
-    assert_allclose(getattr(incbs_spmd, option), getattr(incbs, option))
+    attr = option + "_"
+    assert_allclose(getattr(incbs_spmd, attr), getattr(incbs, attr))
 
 
 @pytest.mark.skipif(
@@ -302,9 +305,10 @@ def test_incremental_basic_statistics_partial_fit_spmd_synthetic(
         incbs.partial_fit(dpt_data, sample_weight=dpt_weights if weighted else None)
 
     for option in options_and_tests:
+        attr = option + "_"
         assert_allclose(
-            getattr(incbs_spmd, option),
-            getattr(incbs, option),
+            _as_numpy(getattr(incbs_spmd, attr)),
+            _as_numpy(getattr(incbs, attr)),
             atol=tol,
             err_msg=f"Result for {option} is incorrect",
         )

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/sklearnex/spmd/cluster/dbscan.py

@@ -0,0 +1,26 @@
+# ==============================================================================
+# 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 abc import ABC
+
+from onedal.spmd.cluster import DBSCAN as onedal_DBSCAN
+
+from ...cluster import DBSCAN as DBSCAN_Batch
+
+
+class DBSCAN(DBSCAN_Batch):
+    __doc__ = DBSCAN_Batch.__doc__
+    _onedal_dbscan = staticmethod(onedal_DBSCAN)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/spmd/covariance/tests/test_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,
 )
@@ -65,8 +66,10 @@ def test_covariance_spmd_gold(dataframe, queue):
     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_)
+    assert_allclose(
+        _as_numpy(spmd_result.covariance_), _as_numpy(batch_result.covariance_)
+    )
+    assert_allclose(_as_numpy(spmd_result.location_), _as_numpy(batch_result.location_))
 
 
 @pytest.mark.skipif(
@@ -106,5 +109,9 @@ def test_covariance_spmd_synthetic(
     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)
+    assert_allclose(
+        _as_numpy(spmd_result.covariance_), _as_numpy(batch_result.covariance_), atol=atol
+    )
+    assert_allclose(
+        _as_numpy(spmd_result.location_), _as_numpy(batch_result.location_), atol=atol
+    )

scikit_learn_intelex-2025.8.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.8.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.8.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)