scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/spmd/decomposition/tests/test_pca_spmd.py

@@ -0,0 +1,146 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex import config_context
+from sklearnex.tests.utils.spmd import (
+    _generate_statistic_data,
+    _get_local_tensor,
+    _mpi_libs_and_gpu_available,
+)
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.mpi
+def test_pca_spmd_gold(dataframe, queue):
+    # Import spmd and batch algo
+    from sklearnex.decomposition import PCA as PCA_Batch
+    from sklearnex.spmd.decomposition import PCA as PCA_SPMD
+
+    # Create gold data and convert to dataframe
+    data = np.array(
+        [
+            [0.0, 0.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, 2.0, 4.0],
+            [0.0, 3.0, 8.0],
+            [0.0, 4.0, 16.0],
+            [0.0, 5.0, 32.0],
+            [0.0, 6.0, 64.0],
+            [0.0, 7.0, 128.0],
+        ]
+    )
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    spmd_result = PCA_SPMD(n_components=2).fit(local_dpt_data)
+    batch_result = PCA_Batch(n_components=2).fit(data)
+
+    assert_allclose(spmd_result.mean_, batch_result.mean_)
+    assert_allclose(spmd_result.components_, batch_result.components_)
+    assert_allclose(spmd_result.singular_values_, batch_result.singular_values_)
+    assert_allclose(
+        spmd_result.noise_variance_,
+        batch_result.noise_variance_,
+        atol=1e-7,
+    )
+    assert_allclose(
+        spmd_result.explained_variance_ratio_, batch_result.explained_variance_ratio_
+    )
+
+
+@pytest.mark.skipif(
+    not _mpi_libs_and_gpu_available,
+    reason="GPU device and MPI libs required for test",
+)
+@pytest.mark.parametrize("n_samples", [100, 10000])
+@pytest.mark.parametrize("n_features", [10, 100])
+@pytest.mark.parametrize("n_components", [0.5, 3, "mle", None])
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize(
+    "dataframe,queue",
+    get_dataframes_and_queues(dataframe_filter_="dpnp,dpctl", device_filter_="gpu"),
+)
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("use_raw_input", [True, False])
+@pytest.mark.mpi
+def test_pca_spmd_synthetic(
+    n_samples, n_features, n_components, whiten, dataframe, queue, dtype, use_raw_input
+):
+    # TODO: Resolve issues with batch fallback and lack of support for n_rows_rank < n_cols
+    if n_components == "mle" or n_components == 3:
+        pytest.skip("Avoid error in case of batch fallback to sklearn")
+    if n_samples <= n_features:
+        pytest.skip("Avoid n_samples < n_features error from spmd data split")
+
+    # Import spmd and batch algo
+    from sklearnex.decomposition import PCA as PCA_Batch
+    from sklearnex.spmd.decomposition import PCA as PCA_SPMD
+
+    # Generate data and convert to dataframe
+    data = _generate_statistic_data(n_samples, n_features, dtype=dtype)
+
+    local_dpt_data = _convert_to_dataframe(
+        _get_local_tensor(data), sycl_queue=queue, target_df=dataframe
+    )
+
+    # Ensure results of batch algo match spmd
+    with config_context(use_raw_input=use_raw_input):
+        spmd_result = PCA_SPMD(n_components=n_components, whiten=whiten).fit(
+            local_dpt_data
+        )
+    batch_result = PCA_Batch(n_components=n_components, whiten=whiten).fit(data)
+
+    tol = 1e-3 if dtype == np.float32 else 1e-7
+    assert_allclose(
+        _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.10.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