scikit-learn-intelex 2024.0.0__py311-none-win_amd64.whl → 2024.0.1__py311-none-win_amd64.whl

scikit_learn_intelex-2024.0.0.data/data/Lib/site-packages/sklearnex/preview/ensemble/extra_trees.py → scikit_learn_intelex-2024.0.1.data/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -24,9 +24,16 @@ from scipy import sparse as sp
 from sklearn.base import clone
 from sklearn.ensemble import ExtraTreesClassifier as sklearn_ExtraTreesClassifier
 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 _get_n_samples_bootstrap
 from sklearn.exceptions import DataConversionWarning
-from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
-from sklearn.tree import ExtraTreeClassifier, ExtraTreeRegressor
+from sklearn.tree import (
+    DecisionTreeClassifier,
+    DecisionTreeRegressor,
+    ExtraTreeClassifier,
+    ExtraTreeRegressor,
+)
 from sklearn.tree._tree import Tree
 from sklearn.utils import check_random_state, deprecated
 from sklearn.utils.validation import (
@@ -53,18 +60,117 @@ try:
 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 ..._config import get_config
-from ..._device_offload import dispatch, wrap_output_data
-from ..._utils import PatchingConditionsChain
+from .._config import get_config
+from .._device_offload import dispatch, wrap_output_data
+from .._utils import PatchingConditionsChain
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
+if sklearn_check_version("1.4"):
+    from daal4py.sklearn.utils import _assert_all_finite
+
+
+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,
+            )
+
+        if sample_weight is not None:
+            sample_weight = self.check_sample_weight(sample_weight, X)
+
+        if y.ndim == 2 and y.shape[1] == 1:
+            warnings.warn(
+                "A column-vector y was passed when a 1d array was"
+                " expected. Please change the shape of y to "
+                "(n_samples,), for example using ravel().",
+                DataConversionWarning,
+                stacklevel=2,
+            )
+
+        if y.ndim == 1:
+            # reshape is necessary to preserve the data contiguity against vs
+            # [:, np.newaxis] that does not.
+            y = np.reshape(y, (-1, 1))
+
+        y, expanded_class_weight = self._validate_y_class_weight(y)
+
+        self.n_features_in_ = X.shape[1]
+
+        if expanded_class_weight is not None:
+            if sample_weight is not None:
+                sample_weight = sample_weight * expanded_class_weight
+            else:
+                sample_weight = expanded_class_weight
+        if sample_weight is not None:
+            sample_weight = [sample_weight]
+
+        onedal_params = {
+            "n_estimators": self.n_estimators,
+            "criterion": self.criterion,
+            "max_depth": self.max_depth,
+            "min_samples_split": self.min_samples_split,
+            "min_samples_leaf": self.min_samples_leaf,
+            "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
+            "max_features": self.max_features,
+            "max_leaf_nodes": self.max_leaf_nodes,
+            "min_impurity_decrease": self.min_impurity_decrease,
+            "bootstrap": self.bootstrap,
+            "oob_score": self.oob_score,
+            "n_jobs": self.n_jobs,
+            "random_state": self.random_state,
+            "verbose": self.verbose,
+            "warm_start": self.warm_start,
+            "error_metric_mode": self._err if self.oob_score else "none",
+            "variable_importance_mode": "mdi",
+            "class_weight": self.class_weight,
+            "max_bins": self.max_bins,
+            "min_bin_size": self.min_bin_size,
+            "max_samples": self.max_samples,
+        }
+
+        if not sklearn_check_version("1.0"):
+            onedal_params["min_impurity_split"] = self.min_impurity_split
+        else:
+            onedal_params["min_impurity_split"] = None
+
+        # Lazy evaluation of estimators_
+        self._cached_estimators_ = None
+
+        # Compute
+        self._onedal_estimator = self._onedal_factory(**onedal_params)
+        self._onedal_estimator.fit(X, np.ravel(y), sample_weight, queue=queue)
+
+        self._save_attributes()
+
+        # Decapsulate classes_ attributes
+        if hasattr(self, "classes_") and self.n_outputs_ == 1:
+            self.n_classes_ = self.n_classes_[0]
+            self.classes_ = self.classes_[0]
 
+        return self
 
-class BaseTree(ABC):
     def _fit_proba(self, X, y, sample_weight=None, queue=None):
         params = self.get_params()
         self.__class__(**params)
@@ -75,8 +181,6 @@ class BaseTree(ABC):
         cfg["target_offload"] = queue
 
     def _save_attributes(self):
-        self._onedal_model = self._onedal_estimator._onedal_model
-
         if self.oob_score:
             self.oob_score_ = self._onedal_estimator.oob_score_
             if hasattr(self._onedal_estimator, "oob_prediction_"):
@@ -85,6 +189,8 @@ class BaseTree(ABC):
                 self.oob_decision_function_ = (
                     self._onedal_estimator.oob_decision_function_
                 )
+
+        self._validate_estimator()
         return self
 
     # TODO:
@@ -183,6 +289,7 @@ class BaseTree(ABC):
                 ensure_2d=False,
                 dtype=dtype,
                 order="C",
+                force_all_finite=False,
             )
             if sample_weight.ndim != 1:
                 raise ValueError("Sample weights must be 1D array or scalar")
@@ -198,7 +305,7 @@ class BaseTree(ABC):
     @property
     def estimators_(self):
         if hasattr(self, "_cached_estimators_"):
-            if self._cached_estimators_ is None and self._onedal_model:
+            if self._cached_estimators_ is None:
                 self._estimators_()
             return self._cached_estimators_
         else:
@@ -211,13 +318,99 @@ class BaseTree(ABC):
         # Needed to allow for proper sklearn operation in fallback mode
         self._cached_estimators_ = estimators
 
+    def _estimators_(self):
+        # _estimators_ should only be called if _onedal_estimator exists
+        check_is_fitted(self, "_onedal_estimator")
+        if hasattr(self, "n_classes_"):
+            n_classes_ = (
+                self.n_classes_
+                if isinstance(self.n_classes_, int)
+                else self.n_classes_[0]
+            )
+        else:
+            n_classes_ = 1
+
+        # convert model to estimators
+        params = {
+            "criterion": self._onedal_estimator.criterion,
+            "max_depth": self._onedal_estimator.max_depth,
+            "min_samples_split": self._onedal_estimator.min_samples_split,
+            "min_samples_leaf": self._onedal_estimator.min_samples_leaf,
+            "min_weight_fraction_leaf": self._onedal_estimator.min_weight_fraction_leaf,
+            "max_features": self._onedal_estimator.max_features,
+            "max_leaf_nodes": self._onedal_estimator.max_leaf_nodes,
+            "min_impurity_decrease": self._onedal_estimator.min_impurity_decrease,
+            "random_state": None,
+        }
+        if not sklearn_check_version("1.0"):
+            params["min_impurity_split"] = self._onedal_estimator.min_impurity_split
+        est = self.estimator.__class__(**params)
+        # we need to set est.tree_ field with Trees constructed from Intel(R)
+        # oneAPI Data Analytics Library solution
+        estimators_ = []
+
+        random_state_checked = check_random_state(self.random_state)
+
+        for i in range(self._onedal_estimator.n_estimators):
+            est_i = clone(est)
+            est_i.set_params(
+                random_state=random_state_checked.randint(np.iinfo(np.int32).max)
+            )
+            if sklearn_check_version("1.0"):
+                est_i.n_features_in_ = self.n_features_in_
+            else:
+                est_i.n_features_ = self.n_features_in_
+            est_i.n_outputs_ = self.n_outputs_
+            est_i.n_classes_ = n_classes_
+            tree_i_state_class = self._get_tree_state(
+                self._onedal_estimator._onedal_model, i, n_classes_
+            )
+            tree_i_state_dict = {
+                "max_depth": tree_i_state_class.max_depth,
+                "node_count": tree_i_state_class.node_count,
+                "nodes": check_tree_nodes(tree_i_state_class.node_ar),
+                "values": tree_i_state_class.value_ar,
+            }
+            est_i.tree_ = Tree(
+                self.n_features_in_,
+                np.array([n_classes_], dtype=np.intp),
+                self.n_outputs_,
+            )
+            est_i.tree_.__setstate__(tree_i_state_dict)
+            estimators_.append(est_i)
+
+        self._cached_estimators_ = estimators_
+
+    if sklearn_check_version("1.0"):
+
+        @deprecated(
+            "Attribute `n_features_` was deprecated in version 1.0 and will be "
+            "removed in 1.2. Use `n_features_in_` instead."
+        )
+        @property
+        def n_features_(self):
+            return self.n_features_in_
+
+    if not sklearn_check_version("1.2"):
+
+        @property
+        def base_estimator(self):
+            return self.estimator
+
+        @base_estimator.setter
+        def base_estimator(self, estimator):
+            self.estimator = estimator
+
 
-class ForestClassifier(sklearn_ForestClassifier, BaseTree):
+class ForestClassifier(sklearn_ForestClassifier, BaseForest):
     # Surprisingly, even though scikit-learn warns against using
     # their ForestClassifier directly, it actually has a more stable
     # API than the user-facing objects (over time). If they change it
     # significantly at some point then this may need to be versioned.
 
+    _err = "out_of_bag_error_accuracy|out_of_bag_error_decision_function"
+    _get_tree_state = staticmethod(get_tree_state_cls)
+
     def __init__(
         self,
         estimator,
@@ -247,16 +440,27 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
             max_samples=max_samples,
         )
 
-        # The splitter is recognized here for proper dispatching.
-        self._estimator = estimator  # TODO: Verify if this is done in older verions
-        if self._estimator.__class__ == DecisionTreeClassifier:
-            self._onedal_classifier = onedal_RandomForestClassifier
-        elif self._estimator.__class__ == ExtraTreeClassifier:
-            self._onedal_classifier = onedal_ExtraTreesClassifier
-        else:
-            raise TypeError(
-                f"{estimator.__class__.__name__} is not a supported tree classifier"
-            )
+        # The estimator is checked against the class attribute for conformance.
+        # This should only trigger if the user uses this class directly.
+        if (
+            self.estimator.__class__ == DecisionTreeClassifier
+            and self._onedal_factory != onedal_RandomForestClassifier
+        ):
+            self._onedal_factory = onedal_RandomForestClassifier
+        elif (
+            self.estimator.__class__ == ExtraTreeClassifier
+            and self._onedal_factory != onedal_ExtraTreesClassifier
+        ):
+            self._onedal_factory = onedal_ExtraTreesClassifier
+
+        if self._onedal_factory is None:
+            raise TypeError(f" oneDAL estimator has not been set.")
+
+    def _estimators_(self):
+        super()._estimators_()
+        classes_ = self.classes_[0]
+        for est in self._cached_estimators_:
+            est.classes_ = classes_
 
     def fit(self, X, y, sample_weight=None):
         dispatch(
@@ -292,17 +496,17 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
                     or not self.oob_score,
                     "OOB score is only supported starting from 2021.5 version of oneDAL.",
                 ),
-                (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
-                (
-                    self.ccp_alpha == 0.0,
-                    f"Non-zero 'ccp_alpha' ({self.ccp_alpha}) is not supported.",
-                ),
+                (self.warm_start is False, "Warm start is not supported."),
                 (
                     self.criterion == "gini",
                     f"'{self.criterion}' criterion is not supported. "
                     "Only 'gini' criterion is supported.",
                 ),
-                (self.warm_start is False, "Warm start is not supported."),
+                (
+                    self.ccp_alpha == 0.0,
+                    f"Non-zero 'ccp_alpha' ({self.ccp_alpha}) is not supported.",
+                ),
+                (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
                 (
                     self.n_estimators <= 6024,
                     "More than 6024 estimators is not supported.",
@@ -310,12 +514,46 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
             ]
         )
 
+        if self.bootstrap:
+            patching_status.and_conditions(
+                [
+                    (
+                        self.class_weight != "balanced_subsample",
+                        "'balanced_subsample' for class_weight is not supported",
+                    )
+                ]
+            )
+
+        if patching_status.get_status() and sklearn_check_version("1.4"):
+            try:
+                _assert_all_finite(X)
+                input_is_finite = True
+            except ValueError:
+                input_is_finite = False
+            patching_status.and_conditions(
+                [
+                    (input_is_finite, "Non-finite input is not supported."),
+                    (
+                        self.monotonic_cst is None,
+                        "Monotonicity constraints are not supported.",
+                    ),
+                ]
+            )
+
         if patching_status.get_status():
-            if sklearn_check_version("1.0"):
-                self._check_feature_names(X, reset=True)
-            X = check_array(X, dtype=[np.float32, np.float64])
-            y = np.asarray(y)
-            y = np.atleast_1d(y)
+            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)
+
             if y.ndim == 2 and y.shape[1] == 1:
                 warnings.warn(
                     "A column-vector y was passed when a 1d array was"
@@ -324,11 +562,12 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
                     DataConversionWarning,
                     stacklevel=2,
                 )
-            check_consistent_length(X, y)
 
             if y.ndim == 1:
                 y = np.reshape(y, (-1, 1))
+
             self.n_outputs_ = y.shape[1]
+
             patching_status.and_conditions(
                 [
                     (
@@ -343,30 +582,7 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
             )
             # TODO: Fix to support integers as input
 
-            n_samples = X.shape[0]
-            if isinstance(self.max_samples, numbers.Integral):
-                if not sklearn_check_version("1.2"):
-                    if not (1 <= self.max_samples <= n_samples):
-                        msg = "`max_samples` must be in range 1 to {} but got value {}"
-                        raise ValueError(msg.format(n_samples, self.max_samples))
-                else:
-                    if self.max_samples > n_samples:
-                        msg = "`max_samples` must be <= n_samples={} but got value {}"
-                        raise ValueError(msg.format(n_samples, self.max_samples))
-            elif isinstance(self.max_samples, numbers.Real):
-                if sklearn_check_version("1.2"):
-                    pass
-                elif sklearn_check_version("1.0"):
-                    if not (0 < float(self.max_samples) <= 1):
-                        msg = "`max_samples` must be in range (0.0, 1.0] but got value {}"
-                        raise ValueError(msg.format(self.max_samples))
-                else:
-                    if not (0 < float(self.max_samples) < 1):
-                        msg = "`max_samples` must be in range (0, 1) but got value {}"
-                        raise ValueError(msg.format(self.max_samples))
-            elif self.max_samples is not None:
-                msg = "`max_samples` should be int or float, but got type '{}'"
-                raise TypeError(msg.format(type(self.max_samples)))
+            _get_n_samples_bootstrap(n_samples=X.shape[0], max_samples=self.max_samples)
 
             if not self.bootstrap and self.max_samples is not None:
                 raise ValueError(
@@ -375,6 +591,17 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
                     "`max_sample=None`."
                 )
 
+            if (
+                patching_status.get_status()
+                and (self.random_state is not None)
+                and (not daal_check_version((2024, "P", 0)))
+            ):
+                warnings.warn(
+                    "Setting 'random_state' value is not supported. "
+                    "State set by oneDAL to default value (777).",
+                    RuntimeWarning,
+                )
+
         return patching_status, X, y, sample_weight
 
     @wrap_output_data
@@ -423,124 +650,57 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
     predict.__doc__ = sklearn_ForestClassifier.predict.__doc__
     predict_proba.__doc__ = sklearn_ForestClassifier.predict_proba.__doc__
 
-    if sklearn_check_version("1.0"):
-
-        @deprecated(
-            "Attribute `n_features_` was deprecated in version 1.0 and will be "
-            "removed in 1.2. Use `n_features_in_` instead."
-        )
-        @property
-        def n_features_(self):
-            return self.n_features_in_
-
-    def _estimators_(self):
-        # _estimators_ should only be called if _onedal_model exists
-        check_is_fitted(self, "_onedal_model")
-        classes_ = self.classes_[0]
-        n_classes_ = (
-            self.n_classes_ if isinstance(self.n_classes_, int) else self.n_classes_[0]
+    def _onedal_cpu_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        patching_status = PatchingConditionsChain(
+            f"sklearn.ensemble.{class_name}.{method_name}"
         )
-        # convert model to estimators
-        params = {
-            "criterion": self.criterion,
-            "max_depth": self.max_depth,
-            "min_samples_split": self.min_samples_split,
-            "min_samples_leaf": self.min_samples_leaf,
-            "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
-            "max_features": self.max_features,
-            "max_leaf_nodes": self.max_leaf_nodes,
-            "min_impurity_decrease": self.min_impurity_decrease,
-            "random_state": None,
-        }
-        if not sklearn_check_version("1.0"):
-            params["min_impurity_split"] = self.min_impurity_split
-        est = self._estimator.__class__(**params)
-        # we need to set est.tree_ field with Trees constructed from Intel(R)
-        # oneAPI Data Analytics Library solution
-        estimators_ = []
 
-        random_state_checked = check_random_state(self.random_state)
+        if method_name == "fit":
+            patching_status, X, y, sample_weight = self._onedal_fit_ready(
+                patching_status, *data
+            )
 
-        for i in range(self.n_estimators):
-            est_i = clone(est)
-            est_i.set_params(
-                random_state=random_state_checked.randint(np.iinfo(np.int32).max)
+            patching_status.and_conditions(
+                [
+                    (
+                        daal_check_version((2023, "P", 200))
+                        or self.estimator.__class__ == DecisionTreeClassifier,
+                        "ExtraTrees only supported starting from oneDAL version 2023.2",
+                    ),
+                    (
+                        not sp.issparse(sample_weight),
+                        "sample_weight is sparse. " "Sparse input is not supported.",
+                    ),
+                ]
             )
-            if sklearn_check_version("1.0"):
-                est_i.n_features_in_ = self.n_features_in_
-            else:
-                est_i.n_features_ = self.n_features_in_
-            est_i.n_outputs_ = self.n_outputs_
-            est_i.classes_ = classes_
-            est_i.n_classes_ = n_classes_
-            tree_i_state_class = get_tree_state_cls(self._onedal_model, i, n_classes_)
-            tree_i_state_dict = {
-                "max_depth": tree_i_state_class.max_depth,
-                "node_count": tree_i_state_class.node_count,
-                "nodes": check_tree_nodes(tree_i_state_class.node_ar),
-                "values": tree_i_state_class.value_ar,
-            }
-            est_i.tree_ = Tree(
-                self.n_features_in_,
-                np.array([n_classes_], dtype=np.intp),
-                self.n_outputs_,
-            )
-            est_i.tree_.__setstate__(tree_i_state_dict)
-            estimators_.append(est_i)
-
-        self._cached_estimators_ = estimators_
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        class_name = self.__class__.__name__
-        patching_status = PatchingConditionsChain(
-            f"sklearn.ensemble.{class_name}.{method_name}"
-        )
-
-        if method_name == "fit":
-            patching_status, X, y, sample_weight = self._onedal_fit_ready(
-                patching_status, *data
-            )
-
-            patching_status.and_conditions(
-                [
-                    (
-                        daal_check_version((2023, "P", 200))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
-                        "ExtraTrees only supported starting from oneDAL version 2023.2",
-                    ),
-                    (
-                        not sp.issparse(sample_weight),
-                        "sample_weight is sparse. " "Sparse input is not supported.",
-                    ),
-                ]
-            )
-
-            if (
-                patching_status.get_status()
-                and (self.random_state is not None)
-                and (not daal_check_version((2024, "P", 0)))
-            ):
-                warnings.warn(
-                    "Setting 'random_state' value is not supported. "
-                    "State set by oneDAL to default value (777).",
-                    RuntimeWarning,
-                )
 
         elif method_name in ["predict", "predict_proba"]:
             X = data[0]
 
             patching_status.and_conditions(
                 [
-                    (hasattr(self, "_onedal_model"), "oneDAL model was not trained."),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."),
                     (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
                     (self.warm_start is False, "Warm start is not supported."),
                     (
                         daal_check_version((2023, "P", 100))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.2",
                     ),
                 ]
             )
+
+            if method_name == "predict_proba":
+                patching_status.and_conditions(
+                    [
+                        (
+                            daal_check_version((2021, "P", 400)),
+                            "oneDAL version is lower than 2021.4.",
+                        )
+                    ]
+                )
+
             if hasattr(self, "n_outputs_"):
                 patching_status.and_conditions(
                     [
@@ -573,24 +733,13 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
                 [
                     (
                         daal_check_version((2023, "P", 100))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
                     (sample_weight is not None, "sample_weight is not supported."),
                 ]
             )
 
-            if (
-                patching_status.get_status()
-                and (self.random_state is not None)
-                and (not daal_check_version((2024, "P", 0)))
-            ):
-                warnings.warn(
-                    "Setting 'random_state' value is not supported. "
-                    "State set by oneDAL to default value (777).",
-                    RuntimeWarning,
-                )
-
         elif method_name in ["predict", "predict_proba"]:
             X = data[0]
 
@@ -625,113 +774,13 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
 
         return patching_status
 
-    def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if sklearn_check_version("1.2"):
-            X, y = self._validate_data(
-                X,
-                y,
-                multi_output=False,
-                accept_sparse=False,
-                dtype=[np.float64, np.float32],
-            )
-        else:
-            X, y = check_X_y(
-                X,
-                y,
-                accept_sparse=False,
-                dtype=[np.float64, np.float32],
-                multi_output=False,
-            )
-
-        if sample_weight is not None:
-            sample_weight = self.check_sample_weight(sample_weight, X)
-
-        y = np.atleast_1d(y)
-        if y.ndim == 2 and y.shape[1] == 1:
-            warnings.warn(
-                "A column-vector y was passed when a 1d array was"
-                " expected. Please change the shape of y to "
-                "(n_samples,), for example using ravel().",
-                DataConversionWarning,
-                stacklevel=2,
-            )
-        if y.ndim == 1:
-            # reshape is necessary to preserve the data contiguity against vs
-            # [:, np.newaxis] that does not.
-            y = np.reshape(y, (-1, 1))
-
-        y, expanded_class_weight = self._validate_y_class_weight(y)
-
-        n_classes_ = self.n_classes_[0]
-        self.n_features_in_ = X.shape[1]
-        if not sklearn_check_version("1.0"):
-            self.n_features_ = self.n_features_in_
-
-        if expanded_class_weight is not None:
-            if sample_weight is not None:
-                sample_weight = sample_weight * expanded_class_weight
-            else:
-                sample_weight = expanded_class_weight
-        if sample_weight is not None:
-            sample_weight = [sample_weight]
-
-        if n_classes_ < 2:
-            raise ValueError("Training data only contain information about one class.")
-
-        if self.oob_score:
-            err = "out_of_bag_error_accuracy|out_of_bag_error_decision_function"
-        else:
-            err = "none"
-
-        onedal_params = {
-            "n_estimators": self.n_estimators,
-            "criterion": self.criterion,
-            "max_depth": self.max_depth,
-            "min_samples_split": self.min_samples_split,
-            "min_samples_leaf": self.min_samples_leaf,
-            "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
-            "max_features": self.max_features,
-            "max_leaf_nodes": self.max_leaf_nodes,
-            "min_impurity_decrease": self.min_impurity_decrease,
-            "bootstrap": self.bootstrap,
-            "oob_score": self.oob_score,
-            "n_jobs": self.n_jobs,
-            "random_state": self.random_state,
-            "verbose": self.verbose,
-            "warm_start": self.warm_start,
-            "error_metric_mode": err,
-            "variable_importance_mode": "mdi",
-            "class_weight": self.class_weight,
-            "max_bins": self.max_bins,
-            "min_bin_size": self.min_bin_size,
-            "max_samples": self.max_samples,
-        }
-        if daal_check_version((2023, "P", 101)):
-            onedal_params["splitter_mode"] = "random"
-        if not sklearn_check_version("1.0"):
-            onedal_params["min_impurity_split"] = self.min_impurity_split
-        else:
-            onedal_params["min_impurity_split"] = None
-
-        # Lazy evaluation of estimators_
-        self._cached_estimators_ = None
-
-        # Compute
-        self._onedal_estimator = self._onedal_classifier(**onedal_params)
-        self._onedal_estimator.fit(X, np.squeeze(y), sample_weight, queue=queue)
-
-        self._save_attributes()
-        if sklearn_check_version("1.2"):
-            self._estimator = ExtraTreeClassifier()
-
-        # Decapsulate classes_ attributes
-        self.n_classes_ = self.n_classes_[0]
-        self.classes_ = self.classes_[0]
-        return self
-
     def _onedal_predict(self, X, queue=None):
-        X = check_array(X, dtype=[np.float32, np.float64])
-        check_is_fitted(self, "_onedal_model")
+        X = check_array(
+            X,
+            dtype=[np.float64, np.float32],
+            force_all_finite=False,
+        )  # Warning, order of dtype matters
+        check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
@@ -740,8 +789,8 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
         return np.take(self.classes_, res.ravel().astype(np.int64, casting="unsafe"))
 
     def _onedal_predict_proba(self, X, queue=None):
-        X = check_array(X, dtype=[np.float64, np.float32])
-        check_is_fitted(self, "_onedal_model")
+        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)
@@ -750,7 +799,10 @@ class ForestClassifier(sklearn_ForestClassifier, BaseTree):
         return self._onedal_estimator.predict_proba(X, queue=queue)
 
 
-class ForestRegressor(sklearn_ForestRegressor, BaseTree):
+class ForestRegressor(sklearn_ForestRegressor, BaseForest):
+    _err = "out_of_bag_error_r2|out_of_bag_error_prediction"
+    _get_tree_state = staticmethod(get_tree_state_reg)
+
     def __init__(
         self,
         estimator,
@@ -778,66 +830,21 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
             max_samples=max_samples,
         )
 
-        # The splitter is recognized here for proper dispatching.
-        self._estimator = estimator  # TODO: Verify if this is done in older verions
-        if self._estimator.__class__ == DecisionTreeRegressor:
-            self._onedal_regressor = onedal_RandomForestRegressor
-        elif self._estimator.__class__ == ExtraTreeRegressor:
-            self._onedal_regressor = onedal_ExtraTreesRegressor
-        else:
-            raise TypeError(
-                f"{estimator.__class__.__name__} is not a supported tree regressor"
-            )
-
-    def _estimators_(self):
-        # _estimators_ should only be called if _onedal_model exists
-        check_is_fitted(self, "_onedal_model")
-        # convert model to estimators
-        params = {
-            "criterion": self.criterion,
-            "max_depth": self.max_depth,
-            "min_samples_split": self.min_samples_split,
-            "min_samples_leaf": self.min_samples_leaf,
-            "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
-            "max_features": self.max_features,
-            "max_leaf_nodes": self.max_leaf_nodes,
-            "min_impurity_decrease": self.min_impurity_decrease,
-            "random_state": None,
-        }
-        if not sklearn_check_version("1.0"):
-            params["min_impurity_split"] = self.min_impurity_split
-        est = self._estimator.__class__(**params)
-        # we need to set est.tree_ field with Trees constructed from Intel(R)
-        # oneAPI Data Analytics Library solution
-        estimators_ = []
-        random_state_checked = check_random_state(self.random_state)
-
-        for i in range(self.n_estimators):
-            est_i = clone(est)
-            est_i.set_params(
-                random_state=random_state_checked.randint(np.iinfo(np.int32).max)
-            )
-            if sklearn_check_version("1.0"):
-                est_i.n_features_in_ = self.n_features_in_
-            else:
-                est_i.n_features_ = self.n_features_in_
-            est_i.n_classes_ = 1
-            est_i.n_outputs_ = self.n_outputs_
-            tree_i_state_class = get_tree_state_reg(self._onedal_model, i)
-            tree_i_state_dict = {
-                "max_depth": tree_i_state_class.max_depth,
-                "node_count": tree_i_state_class.node_count,
-                "nodes": check_tree_nodes(tree_i_state_class.node_ar),
-                "values": tree_i_state_class.value_ar,
-            }
-
-            est_i.tree_ = Tree(
-                self.n_features_in_, np.array([1], dtype=np.intp), self.n_outputs_
-            )
-            est_i.tree_.__setstate__(tree_i_state_dict)
-            estimators_.append(est_i)
+        # The splitter is checked against the class attribute for conformance
+        # This should only trigger if the user uses this class directly.
+        if (
+            self.estimator.__class__ == DecisionTreeRegressor
+            and self._onedal_factory != onedal_RandomForestRegressor
+        ):
+            self._onedal_factory = onedal_RandomForestRegressor
+        elif (
+            self.estimator.__class__ == ExtraTreeRegressor
+            and self._onedal_factory != onedal_ExtraTreesRegressor
+        ):
+            self._onedal_factory = onedal_ExtraTreesRegressor
 
-        self._cached_estimators_ = estimators_
+        if self._onedal_factory is None:
+            raise TypeError(f" oneDAL estimator has not been set.")
 
     def _onedal_fit_ready(self, patching_status, X, y, sample_weight):
         if sp.issparse(y):
@@ -885,12 +892,35 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
             ]
         )
 
+        if patching_status.get_status() and sklearn_check_version("1.4"):
+            try:
+                _assert_all_finite(X)
+                input_is_finite = True
+            except ValueError:
+                input_is_finite = False
+            patching_status.and_conditions(
+                [
+                    (input_is_finite, "Non-finite input is not supported."),
+                    (
+                        self.monotonic_cst is None,
+                        "Monotonicity constraints are not supported.",
+                    ),
+                ]
+            )
+
         if patching_status.get_status():
-            if sklearn_check_version("1.0"):
-                self._check_feature_names(X, reset=True)
-            X = check_array(X, dtype=[np.float64, np.float32])
-            y = np.asarray(y)
-            y = np.atleast_1d(y)
+            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)
 
             if y.ndim == 2 and y.shape[1] == 1:
                 warnings.warn(
@@ -901,15 +931,13 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                     stacklevel=2,
                 )
 
-            y = check_array(y, ensure_2d=False, dtype=X.dtype)
-            check_consistent_length(X, y)
-
             if y.ndim == 1:
                 # reshape is necessary to preserve the data contiguity against vs
                 # [:, np.newaxis] that does not.
                 y = np.reshape(y, (-1, 1))
 
             self.n_outputs_ = y.shape[1]
+
             patching_status.and_conditions(
                 [
                     (
@@ -919,30 +947,8 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                 ]
             )
 
-            n_samples = X.shape[0]
-            if isinstance(self.max_samples, numbers.Integral):
-                if not sklearn_check_version("1.2"):
-                    if not (1 <= self.max_samples <= n_samples):
-                        msg = "`max_samples` must be in range 1 to {} but got value {}"
-                        raise ValueError(msg.format(n_samples, self.max_samples))
-                else:
-                    if self.max_samples > n_samples:
-                        msg = "`max_samples` must be <= n_samples={} but got value {}"
-                        raise ValueError(msg.format(n_samples, self.max_samples))
-            elif isinstance(self.max_samples, numbers.Real):
-                if sklearn_check_version("1.2"):
-                    pass
-                elif sklearn_check_version("1.0"):
-                    if not (0 < float(self.max_samples) <= 1):
-                        msg = "`max_samples` must be in range (0.0, 1.0] but got value {}"
-                        raise ValueError(msg.format(self.max_samples))
-                else:
-                    if not (0 < float(self.max_samples) < 1):
-                        msg = "`max_samples` must be in range (0, 1) but got value {}"
-                        raise ValueError(msg.format(self.max_samples))
-            elif self.max_samples is not None:
-                msg = "`max_samples` should be int or float, but got type '{}'"
-                raise TypeError(msg.format(type(self.max_samples)))
+            # Sklearn function used for doing checks on max_samples attribute
+            _get_n_samples_bootstrap(n_samples=X.shape[0], max_samples=self.max_samples)
 
             if not self.bootstrap and self.max_samples is not None:
                 raise ValueError(
@@ -951,6 +957,17 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                     "`max_sample=None`."
                 )
 
+            if (
+                patching_status.get_status()
+                and (self.random_state is not None)
+                and (not daal_check_version((2024, "P", 0)))
+            ):
+                warnings.warn(
+                    "Setting 'random_state' value is not supported. "
+                    "State set by oneDAL to default value (777).",
+                    RuntimeWarning,
+                )
+
         return patching_status, X, y, sample_weight
 
     def _onedal_cpu_supported(self, method_name, *data):
@@ -968,7 +985,7 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                 [
                     (
                         daal_check_version((2023, "P", 200))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.2",
                     ),
                     (
@@ -978,28 +995,17 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                 ]
             )
 
-            if (
-                patching_status.get_status()
-                and (self.random_state is not None)
-                and (not daal_check_version((2024, "P", 0)))
-            ):
-                warnings.warn(
-                    "Setting 'random_state' value is not supported. "
-                    "State set by oneDAL to default value (777).",
-                    RuntimeWarning,
-                )
-
-        elif method_name in ["predict", "predict_proba"]:
+        elif method_name == "predict":
             X = data[0]
 
             patching_status.and_conditions(
                 [
-                    (hasattr(self, "_onedal_model"), "oneDAL model was not trained."),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."),
                     (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
                     (self.warm_start is False, "Warm start is not supported."),
                     (
                         daal_check_version((2023, "P", 200))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.2",
                     ),
                 ]
@@ -1013,8 +1019,6 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                         ),
                     ]
                 )
-            else:
-                dal_ready = False
 
         else:
             raise RuntimeError(
@@ -1038,35 +1042,24 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
                 [
                     (
                         daal_check_version((2023, "P", 100))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
                     (sample_weight is not None, "sample_weight is not supported."),
                 ]
             )
 
-            if (
-                patching_status.get_status()
-                and (self.random_state is not None)
-                and (not daal_check_version((2024, "P", 0)))
-            ):
-                warnings.warn(
-                    "Setting 'random_state' value is not supported. "
-                    "State set by oneDAL to default value (777).",
-                    RuntimeWarning,
-                )
-
         elif method_name == "predict":
             X = data[0]
 
             patching_status.and_conditions(
                 [
-                    (hasattr(self, "_onedal_model"), "oneDAL model was not trained."),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."),
                     (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
                     (self.warm_start is False, "Warm start is not supported."),
                     (
                         daal_check_version((2023, "P", 100))
-                        or self._estimator.__class__ == DecisionTreeClassifier,
+                        or self.estimator.__class__ == DecisionTreeClassifier,
                         "ExtraTrees only supported starting from oneDAL version 2023.1",
                     ),
                 ]
@@ -1088,76 +1081,11 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
 
         return patching_status
 
-    def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if sp.issparse(y):
-            raise ValueError("sparse multilabel-indicator for y is not supported.")
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-        else:
-            self._check_parameters()
-        if sample_weight is not None:
-            sample_weight = self.check_sample_weight(sample_weight, X)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
-        X = check_array(X, dtype=[np.float64, np.float32])
-        y = np.atleast_1d(np.asarray(y))
-        if y.ndim == 2 and y.shape[1] == 1:
-            warnings.warn(
-                "A column-vector y was passed when a 1d array was"
-                " expected. Please change the shape of y to "
-                "(n_samples,), for example using ravel().",
-                DataConversionWarning,
-                stacklevel=2,
-            )
-        y = check_array(y, ensure_2d=False, dtype=X.dtype)
-        check_consistent_length(X, y)
-        self.n_features_in_ = X.shape[1]
-        if not sklearn_check_version("1.0"):
-            self.n_features_ = self.n_features_in_
-
-        if self.oob_score:
-            err = "out_of_bag_error_r2|out_of_bag_error_prediction"
-        else:
-            err = "none"
-
-        onedal_params = {
-            "n_estimators": self.n_estimators,
-            "criterion": self.criterion,
-            "max_depth": self.max_depth,
-            "min_samples_split": self.min_samples_split,
-            "min_samples_leaf": self.min_samples_leaf,
-            "min_weight_fraction_leaf": self.min_weight_fraction_leaf,
-            "max_features": self.max_features,
-            "max_leaf_nodes": self.max_leaf_nodes,
-            "min_impurity_decrease": self.min_impurity_decrease,
-            "bootstrap": self.bootstrap,
-            "oob_score": self.oob_score,
-            "n_jobs": self.n_jobs,
-            "random_state": self.random_state,
-            "verbose": self.verbose,
-            "warm_start": self.warm_start,
-            "error_metric_mode": err,
-            "variable_importance_mode": "mdi",
-            "max_samples": self.max_samples,
-        }
-        if daal_check_version((2023, "P", 101)):
-            onedal_params["splitter_mode"] = "random"
-
-        # Lazy evaluation of estimators_
-        self._cached_estimators_ = None
-
-        self._onedal_estimator = self._onedal_regressor(**onedal_params)
-        self._onedal_estimator.fit(X, y, sample_weight, queue=queue)
-
-        self._save_attributes()
-        if sklearn_check_version("1.2"):
-            self._estimator = ExtraTreeRegressor()
-
-        return self
-
     def _onedal_predict(self, X, queue=None):
-        X = check_array(X, dtype=[np.float32, np.float64])
-        check_is_fitted(self, "_onedal_model")
+        X = check_array(
+            X, dtype=[np.float64, np.float32], force_all_finite=False
+        )  # Warning, order of dtype matters
+        check_is_fitted(self, "_onedal_estimator")
 
         if sklearn_check_version("1.0"):
             self._check_feature_names(X, reset=False)
@@ -1193,28 +1121,85 @@ class ForestRegressor(sklearn_ForestRegressor, BaseTree):
     fit.__doc__ = sklearn_ForestRegressor.fit.__doc__
     predict.__doc__ = sklearn_ForestRegressor.predict.__doc__
 
-    if sklearn_check_version("1.0"):
-
-        @deprecated(
-            "Attribute `n_features_` was deprecated in version 1.0 and will be "
-            "removed in 1.2. Use `n_features_in_` instead."
-        )
-        @property
-        def n_features_(self):
-            return self.n_features_in_
-
 
-class ExtraTreesClassifier(ForestClassifier):
-    __doc__ = sklearn_ExtraTreesClassifier.__doc__
+class RandomForestClassifier(ForestClassifier):
+    __doc__ = sklearn_RandomForestClassifier.__doc__
+    _onedal_factory = onedal_RandomForestClassifier
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_ExtraTreesClassifier._parameter_constraints,
+            **sklearn_RandomForestClassifier._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
 
-    if sklearn_check_version("1.0"):
+    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,
+        ):
+            super().__init__(
+                DecisionTreeClassifier(),
+                n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                    "monotonic_cst",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+            self.monotonic_cst = monotonic_cst
+
+    elif sklearn_check_version("1.0"):
 
         def __init__(
             self,
@@ -1228,7 +1213,7 @@ class ExtraTreesClassifier(ForestClassifier):
             max_features="sqrt" if sklearn_check_version("1.1") else "auto",
             max_leaf_nodes=None,
             min_impurity_decrease=0.0,
-            bootstrap=False,
+            bootstrap=True,
             oob_score=False,
             n_jobs=None,
             random_state=None,
@@ -1241,7 +1226,7 @@ class ExtraTreesClassifier(ForestClassifier):
             min_bin_size=1,
         ):
             super().__init__(
-                ExtraTreeClassifier(),
+                DecisionTreeClassifier(),
                 n_estimators,
                 estimator_params=(
                     "criterion",
@@ -1292,7 +1277,7 @@ class ExtraTreesClassifier(ForestClassifier):
             max_leaf_nodes=None,
             min_impurity_decrease=0.0,
             min_impurity_split=None,
-            bootstrap=False,
+            bootstrap=True,
             oob_score=False,
             n_jobs=None,
             random_state=None,
@@ -1305,7 +1290,7 @@ class ExtraTreesClassifier(ForestClassifier):
             min_bin_size=1,
         ):
             super().__init__(
-                ExtraTreeClassifier(),
+                DecisionTreeClassifier(),
                 n_estimators,
                 estimator_params=(
                     "criterion",
@@ -1346,17 +1331,82 @@ class ExtraTreesClassifier(ForestClassifier):
             self.min_bin_size = min_bin_size
 
 
-class ExtraTreesRegressor(ForestRegressor):
-    __doc__ = sklearn_ExtraTreesRegressor.__doc__
+class RandomForestRegressor(ForestRegressor):
+    __doc__ = sklearn_RandomForestRegressor.__doc__
+    _onedal_factory = onedal_RandomForestRegressor
 
     if sklearn_check_version("1.2"):
         _parameter_constraints: dict = {
-            **sklearn_ExtraTreesRegressor._parameter_constraints,
+            **sklearn_RandomForestRegressor._parameter_constraints,
             "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
             "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
         }
 
-    if sklearn_check_version("1.0"):
+    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,
+        ):
+            super().__init__(
+                DecisionTreeRegressor(),
+                n_estimators=n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                    "monotonic_cst",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+            self.monotonic_cst = monotonic_cst
+
+    elif sklearn_check_version("1.0"):
 
         def __init__(
             self,
@@ -1370,7 +1420,7 @@ class ExtraTreesRegressor(ForestRegressor):
             max_features=1.0 if sklearn_check_version("1.1") else "auto",
             max_leaf_nodes=None,
             min_impurity_decrease=0.0,
-            bootstrap=False,
+            bootstrap=True,
             oob_score=False,
             n_jobs=None,
             random_state=None,
@@ -1382,7 +1432,7 @@ class ExtraTreesRegressor(ForestRegressor):
             min_bin_size=1,
         ):
             super().__init__(
-                estimator=ExtraTreeRegressor(),
+                DecisionTreeRegressor(),
                 n_estimators=n_estimators,
                 estimator_params=(
                     "criterion",
@@ -1432,7 +1482,7 @@ class ExtraTreesRegressor(ForestRegressor):
             max_leaf_nodes=None,
             min_impurity_decrease=0.0,
             min_impurity_split=None,
-            bootstrap=False,
+            bootstrap=True,
             oob_score=False,
             n_jobs=None,
             random_state=None,
@@ -1444,7 +1494,7 @@ class ExtraTreesRegressor(ForestRegressor):
             min_bin_size=1,
         ):
             super().__init__(
-                estimator=ExtraTreeRegressor(),
+                DecisionTreeRegressor(),
                 n_estimators=n_estimators,
                 estimator_params=(
                     "criterion",
@@ -1479,3 +1529,419 @@ class ExtraTreesRegressor(ForestRegressor):
             self.ccp_alpha = ccp_alpha
             self.max_bins = max_bins
             self.min_bin_size = min_bin_size
+
+
+class ExtraTreesClassifier(ForestClassifier):
+    __doc__ = sklearn_ExtraTreesClassifier.__doc__
+    _onedal_factory = onedal_ExtraTreesClassifier
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **sklearn_ExtraTreesClassifier._parameter_constraints,
+            "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
+            "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
+        }
+
+    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=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeClassifier(),
+                n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                    "monotonic_cst",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+            self.monotonic_cst = monotonic_cst
+
+    elif sklearn_check_version("1.0"):
+
+        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=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeClassifier(),
+                n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.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="auto",
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            min_impurity_split=None,
+            bootstrap=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeClassifier(),
+                n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "min_impurity_split",
+                    "random_state",
+                    "ccp_alpha",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                class_weight=class_weight,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.min_impurity_split = min_impurity_split
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+
+
+class ExtraTreesRegressor(ForestRegressor):
+    __doc__ = sklearn_ExtraTreesRegressor.__doc__
+    _onedal_factory = onedal_ExtraTreesRegressor
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **sklearn_ExtraTreesRegressor._parameter_constraints,
+            "max_bins": [Interval(numbers.Integral, 2, None, closed="left")],
+            "min_bin_size": [Interval(numbers.Integral, 1, None, closed="left")],
+        }
+
+    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=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeRegressor(),
+                n_estimators=n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                    "monotonic_cst",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+            self.monotonic_cst = monotonic_cst
+
+    elif sklearn_check_version("1.0"):
+
+        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=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeRegressor(),
+                n_estimators=n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "random_state",
+                    "ccp_alpha",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+
+    else:
+
+        def __init__(
+            self,
+            n_estimators=100,
+            *,
+            criterion="mse",
+            max_depth=None,
+            min_samples_split=2,
+            min_samples_leaf=1,
+            min_weight_fraction_leaf=0.0,
+            max_features="auto",
+            max_leaf_nodes=None,
+            min_impurity_decrease=0.0,
+            min_impurity_split=None,
+            bootstrap=False,
+            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,
+        ):
+            super().__init__(
+                ExtraTreeRegressor(),
+                n_estimators=n_estimators,
+                estimator_params=(
+                    "criterion",
+                    "max_depth",
+                    "min_samples_split",
+                    "min_samples_leaf",
+                    "min_weight_fraction_leaf",
+                    "max_features",
+                    "max_leaf_nodes",
+                    "min_impurity_decrease",
+                    "min_impurity_split" "random_state",
+                    "ccp_alpha",
+                ),
+                bootstrap=bootstrap,
+                oob_score=oob_score,
+                n_jobs=n_jobs,
+                random_state=random_state,
+                verbose=verbose,
+                warm_start=warm_start,
+                max_samples=max_samples,
+            )
+
+            self.criterion = criterion
+            self.max_depth = max_depth
+            self.min_samples_split = min_samples_split
+            self.min_samples_leaf = min_samples_leaf
+            self.min_weight_fraction_leaf = min_weight_fraction_leaf
+            self.max_features = max_features
+            self.max_leaf_nodes = max_leaf_nodes
+            self.min_impurity_decrease = min_impurity_decrease
+            self.min_impurity_split = min_impurity_split
+            self.ccp_alpha = ccp_alpha
+            self.max_bins = max_bins
+            self.min_bin_size = min_bin_size
+
+
+# Allow for isinstance calls without inheritance changes using ABCMeta
+sklearn_RandomForestClassifier.register(RandomForestClassifier)
+sklearn_RandomForestRegressor.register(RandomForestRegressor)
+sklearn_ExtraTreesClassifier.register(ExtraTreesClassifier)
+sklearn_ExtraTreesRegressor.register(ExtraTreesRegressor)