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

scikit_learn_intelex-2024.4.0.data/data/Lib/site-packages/sklearnex/basic_statistics/tests/test_incremental_basic_statistics.py

@@ -0,0 +1,386 @@
+# ===============================================================================
+# 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.basic_statistics.tests.test_incremental_basic_statistics import (
+    expected_max,
+    expected_mean,
+    expected_sum,
+    options_and_tests,
+)
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.basic_statistics import IncrementalBasicStatistics
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_multiple_options_on_gold_data(dataframe, queue, weighted, dtype):
+    X = np.array([[0, 0], [1, 1]])
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, 2)
+    if weighted:
+        weights = np.array([1, 0.5])
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, 2)
+
+    incbs = IncrementalBasicStatistics()
+    for i in range(2):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            weights_split_df = _convert_to_dataframe(
+                weights_split[i], sycl_queue=queue, target_df=dataframe
+            )
+            result = incbs.partial_fit(X_split_df, sample_weight=weights_split_df)
+        else:
+            result = incbs.partial_fit(X_split_df)
+
+    if weighted:
+        expected_weighted_mean = np.array([0.25, 0.25])
+        expected_weighted_min = np.array([0, 0])
+        expected_weighted_max = np.array([0.5, 0.5])
+        assert_allclose(expected_weighted_mean, result.mean)
+        assert_allclose(expected_weighted_max, result.max)
+        assert_allclose(expected_weighted_min, result.min)
+    else:
+        expected_mean = np.array([0.5, 0.5])
+        expected_min = np.array([0, 0])
+        expected_max = np.array([1, 1])
+        assert_allclose(expected_mean, result.mean)
+        assert_allclose(expected_max, result.max)
+        assert_allclose(expected_min, result.min)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_single_option_on_random_data(
+    dataframe, queue, num_batches, option, row_count, column_count, weighted, dtype
+):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options=result_option)
+
+    for i in range(num_batches):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            weights_split_df = _convert_to_dataframe(
+                weights_split[i], sycl_queue=queue, target_df=dataframe
+            )
+            result = incbs.partial_fit(X_split_df, sample_weight=weights_split_df)
+        else:
+            result = incbs.partial_fit(X_split_df)
+
+    res = getattr(result, result_option)
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+        gtr = function(weighted_data)
+    else:
+        gtr = function(X)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_multiple_options_on_random_data(
+    dataframe, queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 42
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options=["mean", "max", "sum"])
+
+    for i in range(num_batches):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            weights_split_df = _convert_to_dataframe(
+                weights_split[i], sycl_queue=queue, target_df=dataframe
+            )
+            result = incbs.partial_fit(X_split_df, sample_weight=weights_split_df)
+        else:
+            result = incbs.partial_fit(X_split_df)
+
+    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(weighted_data),
+            expected_max(weighted_data),
+            expected_sum(weighted_data),
+        )
+    else:
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(X),
+            expected_max(X),
+            expected_sum(X),
+        )
+
+    tol = 1e-5 if res_mean.dtype == np.float32 else 1e-7
+    assert_allclose(gtr_mean, res_mean, atol=tol)
+    assert_allclose(gtr_max, res_max, atol=tol)
+    assert_allclose(gtr_sum, res_sum, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_all_option_on_random_data(
+    dataframe, queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_batches)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_split = np.array_split(weights, num_batches)
+    incbs = IncrementalBasicStatistics(result_options="all")
+
+    for i in range(num_batches):
+        X_split_df = _convert_to_dataframe(
+            X_split[i], sycl_queue=queue, target_df=dataframe
+        )
+        if weighted:
+            weights_split_df = _convert_to_dataframe(
+                weights_split[i], sycl_queue=queue, target_df=dataframe
+            )
+            result = incbs.partial_fit(X_split_df, sample_weight=weights_split_df)
+        else:
+            result = incbs.partial_fit(X_split_df)
+
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+
+    for option in options_and_tests:
+        result_option, function, tols = option
+        print(result_option)
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option)
+        if weighted:
+            gtr = function(weighted_data)
+        else:
+            gtr = function(X)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_fit_multiple_options_on_gold_data(dataframe, queue, weighted, dtype):
+    X = np.array([[0, 0], [1, 1]])
+    X = X.astype(dtype=dtype)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    if weighted:
+        weights = np.array([1, 0.5])
+        weights = weights.astype(dtype=dtype)
+        weights_df = _convert_to_dataframe(weights, sycl_queue=queue, target_df=dataframe)
+    incbs = IncrementalBasicStatistics(batch_size=1)
+
+    if weighted:
+        result = incbs.fit(X_df, sample_weight=weights_df)
+    else:
+        result = incbs.fit(X_df)
+
+    if weighted:
+        expected_weighted_mean = np.array([0.25, 0.25])
+        expected_weighted_min = np.array([0, 0])
+        expected_weighted_max = np.array([0.5, 0.5])
+        assert_allclose(expected_weighted_mean, result.mean)
+        assert_allclose(expected_weighted_max, result.max)
+        assert_allclose(expected_weighted_min, result.min)
+    else:
+        expected_mean = np.array([0.5, 0.5])
+        expected_min = np.array([0, 0])
+        expected_max = np.array([1, 1])
+        assert_allclose(expected_mean, result.mean)
+        assert_allclose(expected_max, result.max)
+        assert_allclose(expected_min, result.min)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("option", options_and_tests)
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_fit_single_option_on_random_data(
+    dataframe, queue, num_batches, option, row_count, column_count, weighted, dtype
+):
+    result_option, function, tols = option
+    fp32tol, fp64tol = tols
+    seed = 77
+    gen = np.random.default_rng(seed)
+    batch_size = row_count // num_batches
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_df = _convert_to_dataframe(weights, sycl_queue=queue, target_df=dataframe)
+    incbs = IncrementalBasicStatistics(
+        result_options=result_option, batch_size=batch_size
+    )
+
+    if weighted:
+        result = incbs.fit(X_df, sample_weight=weights_df)
+    else:
+        result = incbs.fit(X_df)
+
+    res = getattr(result, result_option)
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+        gtr = function(weighted_data)
+    else:
+        gtr = function(X)
+
+    tol = fp32tol if res.dtype == np.float32 else fp64tol
+    assert_allclose(gtr, res, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_partial_fit_multiple_options_on_random_data(
+    dataframe, queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 77
+    gen = np.random.default_rng(seed)
+    batch_size = row_count // num_batches
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_df = _convert_to_dataframe(weights, sycl_queue=queue, target_df=dataframe)
+    incbs = IncrementalBasicStatistics(
+        result_options=["mean", "max", "sum"], batch_size=batch_size
+    )
+
+    if weighted:
+        result = incbs.fit(X_df, sample_weight=weights_df)
+    else:
+        result = incbs.fit(X_df)
+
+    res_mean, res_max, res_sum = result.mean, result.max, result.sum
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(weighted_data),
+            expected_max(weighted_data),
+            expected_sum(weighted_data),
+        )
+    else:
+        gtr_mean, gtr_max, gtr_sum = (
+            expected_mean(X),
+            expected_max(X),
+            expected_sum(X),
+        )
+
+    tol = 3e-4 if res_mean.dtype == np.float32 else 1e-7
+    assert_allclose(gtr_mean, res_mean, atol=tol)
+    assert_allclose(gtr_max, res_max, atol=tol)
+    assert_allclose(gtr_sum, res_sum, atol=tol)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("num_batches", [2, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_fit_all_option_on_random_data(
+    dataframe, queue, num_batches, row_count, column_count, weighted, dtype
+):
+    seed = 77
+    gen = np.random.default_rng(seed)
+    batch_size = row_count // num_batches
+    X = gen.uniform(low=-0.3, high=+0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    if weighted:
+        weights = gen.uniform(low=-0.5, high=+1.0, size=row_count)
+        weights = weights.astype(dtype=dtype)
+        weights_df = _convert_to_dataframe(weights, sycl_queue=queue, target_df=dataframe)
+    incbs = IncrementalBasicStatistics(result_options="all", batch_size=batch_size)
+
+    if weighted:
+        result = incbs.fit(X_df, sample_weight=weights_df)
+    else:
+        result = incbs.fit(X_df)
+
+    if weighted:
+        weighted_data = np.diag(weights) @ X
+
+    for option in options_and_tests:
+        result_option, function, tols = option
+        print(result_option)
+        fp32tol, fp64tol = tols
+        res = getattr(result, result_option)
+        if weighted:
+            gtr = function(weighted_data)
+        else:
+            gtr = function(X)
+        tol = fp32tol if res.dtype == np.float32 else fp64tol
+        assert_allclose(gtr, res, atol=tol)

{scikit_learn_intelex-2024.3.0.data → scikit_learn_intelex-2024.4.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -95,6 +95,7 @@ if daal_check_version((2024, "P", 100)):
             self._fit(X)
             return self
 
+        @wrap_output_data
         def _fit(self, X):
             if sklearn_check_version("1.2"):
                 self._validate_params()
@@ -166,13 +167,11 @@ if daal_check_version((2024, "P", 100)):
 
             return self._onedal_estimator.predict(X, queue=queue)
 
-        @wrap_output_data
         def fit_transform(self, X, y=None):
             U, S, Vt = self._fit(X)
             if U is None:
                 # oneDAL PCA was fit
-                X_transformed = self._onedal_transform(X)
-                return X_transformed
+                return self.transform(X)
             else:
                 # Scikit-learn PCA was fit
                 U = U[:, : self.n_components_]
@@ -298,11 +297,9 @@ if daal_check_version((2024, "P", 100)):
             self.n_samples_ = self._onedal_estimator.n_samples_
             if sklearn_check_version("1.2"):
                 self.n_features_in_ = self._onedal_estimator.n_features_
-            elif sklearn_check_version("0.24"):
-                self.n_features_ = self._onedal_estimator.n_features_
-                self.n_features_in_ = self._onedal_estimator.n_features_
             else:
                 self.n_features_ = self._onedal_estimator.n_features_
+                self.n_features_in_ = self._onedal_estimator.n_features_
             self.n_components_ = self._onedal_estimator.n_components_
             self.components_ = self._onedal_estimator.components_
             self.mean_ = self._onedal_estimator.mean_

{scikit_learn_intelex-2024.3.0.data → scikit_learn_intelex-2024.4.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -314,10 +314,10 @@ def get_patch_names():
 def patch_sklearn(name=None, verbose=True, global_patch=False, preview=False):
     if preview:
         os.environ["SKLEARNEX_PREVIEW"] = "enabled_via_patch_sklearn"
-    if not sklearn_check_version("0.22"):
+    if not sklearn_check_version("0.24"):
         raise NotImplementedError(
             "Intel(R) Extension for Scikit-learn* patches apply "
-            "for scikit-learn >= 0.22 only ..."
+            "for scikit-learn >= 0.24 only ..."
         )
 
     if global_patch:

{scikit_learn_intelex-2024.3.0.data → scikit_learn_intelex-2024.4.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -25,8 +25,11 @@ from sklearn.ensemble import ExtraTreesClassifier as sklearn_ExtraTreesClassifie
 from sklearn.ensemble import ExtraTreesRegressor as sklearn_ExtraTreesRegressor
 from sklearn.ensemble import RandomForestClassifier as sklearn_RandomForestClassifier
 from sklearn.ensemble import RandomForestRegressor as sklearn_RandomForestRegressor
+from sklearn.ensemble._forest import ForestClassifier as sklearn_ForestClassifier
+from sklearn.ensemble._forest import ForestRegressor as sklearn_ForestRegressor
 from sklearn.ensemble._forest import _get_n_samples_bootstrap
 from sklearn.exceptions import DataConversionWarning
+from sklearn.metrics import accuracy_score
 from sklearn.tree import (
     DecisionTreeClassifier,
     DecisionTreeRegressor,
@@ -35,12 +38,7 @@ from sklearn.tree import (
 )
 from sklearn.tree._tree import Tree
 from sklearn.utils import check_random_state, deprecated
-from sklearn.utils.validation import (
-    check_array,
-    check_consistent_length,
-    check_is_fitted,
-    check_X_y,
-)
+from sklearn.utils.validation import check_array, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import (
@@ -52,19 +50,10 @@ from onedal.ensemble import ExtraTreesClassifier as onedal_ExtraTreesClassifier
 from onedal.ensemble import ExtraTreesRegressor as onedal_ExtraTreesRegressor
 from onedal.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
-
-# try catch needed for changes in structures observed in Scikit-learn around v0.22
-try:
-    from sklearn.ensemble._forest import ForestClassifier as sklearn_ForestClassifier
-    from sklearn.ensemble._forest import ForestRegressor as sklearn_ForestRegressor
-except ModuleNotFoundError:
-    from sklearn.ensemble.forest import ForestClassifier as sklearn_ForestClassifier
-    from sklearn.ensemble.forest import ForestRegressor as sklearn_ForestRegressor
-
 from onedal.primitives import get_tree_state_cls, get_tree_state_reg
 from onedal.utils import _num_features, _num_samples
+from sklearnex.utils import get_namespace
 
-from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
 
@@ -78,24 +67,14 @@ class BaseForest(ABC):
     _onedal_factory = None
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if sklearn_check_version("0.24"):
-            X, y = self._validate_data(
-                X,
-                y,
-                multi_output=False,
-                accept_sparse=False,
-                dtype=[np.float64, np.float32],
-                force_all_finite=False,
-            )
-        else:
-            X, y = check_X_y(
-                X,
-                y,
-                accept_sparse=False,
-                dtype=[np.float64, np.float32],
-                multi_output=False,
-                force_all_finite=False,
-            )
+        X, y = self._validate_data(
+            X,
+            y,
+            multi_output=False,
+            accept_sparse=False,
+            dtype=[np.float64, np.float32],
+            force_all_finite=False,
+        )
 
         if sample_weight is not None:
             sample_weight = self.check_sample_weight(sample_weight, X)
@@ -173,15 +152,6 @@ class BaseForest(ABC):
 
         return self
 
-    def _fit_proba(self, X, y, sample_weight=None, queue=None):
-        params = self.get_params()
-        self.__class__(**params)
-
-        # We use stock metaestimators below, so the only way
-        # to pass a queue is using config_context.
-        cfg = get_config()
-        cfg["target_offload"] = queue
-
     def _save_attributes(self):
         if self.oob_score:
             self.oob_score_ = self._onedal_estimator.oob_score_
@@ -204,8 +174,6 @@ class BaseForest(ABC):
         self._validate_estimator()
         return self
 
-    # TODO:
-    # move to onedal modul.
     def _check_parameters(self):
         if isinstance(self.min_samples_leaf, numbers.Integral):
             if not 1 <= self.min_samples_leaf:
@@ -550,18 +518,14 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
             )
 
         if patching_status.get_status():
-            if sklearn_check_version("0.24"):
-                X, y = self._validate_data(
-                    X,
-                    y,
-                    multi_output=True,
-                    accept_sparse=True,
-                    dtype=[np.float64, np.float32],
-                    force_all_finite=False,
-                )
-            else:
-                X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=False)
-                y = check_array(y, ensure_2d=False, dtype=X.dtype, force_all_finite=False)
+            X, y = self._validate_data(
+                X,
+                y,
+                multi_output=True,
+                accept_sparse=True,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+            )
 
             if y.ndim == 2 and y.shape[1] == 1:
                 warnings.warn(
@@ -655,9 +619,38 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
             X,
         )
 
+    def predict_log_proba(self, X):
+        xp, _ = get_namespace(X)
+        proba = self.predict_proba(X)
+
+        if self.n_outputs_ == 1:
+            return xp.log(proba)
+
+        else:
+            for k in range(self.n_outputs_):
+                proba[k] = xp.log(proba[k])
+
+            return proba
+
+    @wrap_output_data
+    def score(self, X, y, sample_weight=None):
+        return dispatch(
+            self,
+            "score",
+            {
+                "onedal": self.__class__._onedal_score,
+                "sklearn": sklearn_ForestClassifier.score,
+            },
+            X,
+            y,
+            sample_weight=sample_weight,
+        )
+
     fit.__doc__ = sklearn_ForestClassifier.fit.__doc__
     predict.__doc__ = sklearn_ForestClassifier.predict.__doc__
     predict_proba.__doc__ = sklearn_ForestClassifier.predict_proba.__doc__
+    predict_log_proba.__doc__ = sklearn_ForestClassifier.predict_log_proba.__doc__
+    score.__doc__ = sklearn_ForestClassifier.score.__doc__
 
     def _onedal_cpu_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -684,7 +677,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
                 ]
             )
 
-        elif method_name in ["predict", "predict_proba"]:
+        elif method_name in ["predict", "predict_proba", "score"]:
             X = data[0]
 
             patching_status.and_conditions(
@@ -749,7 +742,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
                 ]
             )
 
-        elif method_name in ["predict", "predict_proba"]:
+        elif method_name in ["predict", "predict_proba", "score"]:
             X = data[0]
 
             patching_status.and_conditions(
@@ -801,12 +794,16 @@ class ForestClassifier(sklearn_ForestClassifier, BaseForest):
         X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=False)
         check_is_fitted(self, "_onedal_estimator")
 
-        if sklearn_check_version("0.23"):
-            self._check_n_features(X, reset=False)
+        self._check_n_features(X, reset=False)
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
         return self._onedal_estimator.predict_proba(X, queue=queue)
 
+    def _onedal_score(self, X, y, sample_weight=None, queue=None):
+        return accuracy_score(
+            y, self._onedal_predict(X, queue=queue), sample_weight=sample_weight
+        )
+
 
 class ForestRegressor(sklearn_ForestRegressor, BaseForest):
     _err = "out_of_bag_error_r2|out_of_bag_error_prediction"
@@ -916,18 +913,14 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
             )
 
         if patching_status.get_status():
-            if sklearn_check_version("0.24"):
-                X, y = self._validate_data(
-                    X,
-                    y,
-                    multi_output=True,
-                    accept_sparse=True,
-                    dtype=[np.float64, np.float32],
-                    force_all_finite=False,
-                )
-            else:
-                X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=False)
-                y = check_array(y, ensure_2d=False, dtype=X.dtype, force_all_finite=False)
+            X, y = self._validate_data(
+                X,
+                y,
+                multi_output=True,
+                accept_sparse=True,
+                dtype=[np.float64, np.float32],
+                force_all_finite=False,
+            )
 
             if y.ndim == 2 and y.shape[1] == 1:
                 warnings.warn(
@@ -1129,7 +1122,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseForest):
     predict.__doc__ = sklearn_ForestRegressor.predict.__doc__
 
 
-@control_n_jobs(decorated_methods=["fit", "predict", "predict_proba"])
+@control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])
 class RandomForestClassifier(ForestClassifier):
     __doc__ = sklearn_RandomForestClassifier.__doc__
     _onedal_factory = onedal_RandomForestClassifier
@@ -1540,7 +1533,7 @@ class RandomForestRegressor(ForestRegressor):
             self.min_bin_size = min_bin_size
 
 
-@control_n_jobs(decorated_methods=["fit", "predict", "predict_proba"])
+@control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])
 class ExtraTreesClassifier(ForestClassifier):
     __doc__ = sklearn_ExtraTreesClassifier.__doc__
     _onedal_factory = onedal_ExtraTreesClassifier