[enhancement] WIP: move finite check to sklearnex in ensemble algos

onedal/ensemble/forest.py

@@ -17,11 +17,7 @@
 import numbers
 import warnings
 from abc import ABCMeta, abstractmethod
-from math import ceil
-
-import numpy as np
-from sklearn.ensemble import BaseEnsemble
-from sklearn.utils import check_random_state
+import math
 
 from daal4py.sklearn._utils import daal_check_version
 from onedal._device_offload import supports_queue
@@ -34,13 +30,6 @@
 from ..common._mixin import ClassifierMixin, RegressorMixin
 from ..datatypes import from_table, to_table
 from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation import (
-    _check_array,
-    _check_n_features,
-    _check_X_y,
-    _column_or_1d,
-    _validate_targets,
-)
 
 
 class BaseForest(BaseEnsemble, metaclass=ABCMeta):
@@ -110,8 +99,8 @@ def _to_absolute_max_features(self, n_features):
         if self.max_features is None:
             return n_features
         elif isinstance(self.max_features, str):
-            return max(1, int(getattr(np, self.max_features)(n_features)))
-        elif isinstance(self.max_features, (numbers.Integral, np.integer)):
+            return max(1, int(getattr(math, self.max_features)(n_features)))
+        elif isinstance(self.max_features, numbers.Integral):
             return self.max_features
         elif self.max_features > 0.0:
             return max(1, int(self.max_features * n_features))
@@ -142,31 +131,18 @@ def _get_onedal_params(self, data):
         self.observations_per_tree_fraction = (
             self.observations_per_tree_fraction if bool(self.bootstrap) else 1.0
         )
-
-        if not self.bootstrap and self.max_samples is not None:
-            raise ValueError(
-                "`max_sample` cannot be set if `bootstrap=False`. "
-                "Either switch to `bootstrap=True` or set "
-                "`max_sample=None`."
-            )
-        if not self.bootstrap and self.oob_score:
-            raise ValueError("Out of bag estimation only available" " if bootstrap=True")
-
         min_observations_in_leaf_node = (
             self.min_samples_leaf
             if isinstance(self.min_samples_leaf, numbers.Integral)
-            else int(ceil(self.min_samples_leaf * n_samples))
+            else int(math.ceil(self.min_samples_leaf * n_samples))
         )
 
         min_observations_in_split_node = (
             self.min_samples_split
             if isinstance(self.min_samples_split, numbers.Integral)
-            else int(ceil(self.min_samples_split * n_samples))
+            else int(math.ceil(self.min_samples_split * n_samples))
         )
 
-        rs = check_random_state(self.random_state)
-        seed = rs.randint(0, np.iinfo("i").max)
-
         onedal_params = {
             "fptype": data.dtype,
             "method": self.algorithm,
@@ -186,7 +162,7 @@ def _get_onedal_params(self, data):
             "max_leaf_nodes": (0 if self.max_leaf_nodes is None else self.max_leaf_nodes),
             "max_bins": self.max_bins,
             "min_bin_size": self.min_bin_size,
-            "seed": seed,
+            "seed": self.random_state,
             "memory_saving_mode": False,
             "bootstrap": bool(self.bootstrap),
             "error_metric_mode": self.error_metric_mode,
@@ -200,81 +176,6 @@ def _get_onedal_params(self, data):
             onedal_params["splitter_mode"] = self.splitter_mode
         return onedal_params
 
-    def _check_parameters(self):
-        if isinstance(self.min_samples_leaf, numbers.Integral):
-            if not 1 <= self.min_samples_leaf:
-                raise ValueError(
-                    "min_samples_leaf must be at least 1 "
-                    "or in (0, 0.5], got %s" % self.min_samples_leaf
-                )
-        else:  # float
-            if not 0.0 < self.min_samples_leaf <= 0.5:
-                raise ValueError(
-                    "min_samples_leaf must be at least 1 "
-                    "or in (0, 0.5], got %s" % self.min_samples_leaf
-                )
-        if isinstance(self.min_samples_split, numbers.Integral):
-            if not 2 <= self.min_samples_split:
-                raise ValueError(
-                    "min_samples_split must be an integer "
-                    "greater than 1 or a float in (0.0, 1.0]; "
-                    "got the integer %s" % self.min_samples_split
-                )
-        else:  # float
-            if not 0.0 < self.min_samples_split <= 1.0:
-                raise ValueError(
-                    "min_samples_split must be an integer "
-                    "greater than 1 or a float in (0.0, 1.0]; "
-                    "got the float %s" % self.min_samples_split
-                )
-        if not 0 <= self.min_weight_fraction_leaf <= 0.5:
-            raise ValueError("min_weight_fraction_leaf must in [0, 0.5]")
-        if self.min_impurity_split is not None:
-            warnings.warn(
-                "The min_impurity_split parameter is deprecated. "
-                "Its default value has changed from 1e-7 to 0 in "
-                "version 0.23, and it will be removed in 0.25. "
-                "Use the min_impurity_decrease parameter instead.",
-                FutureWarning,
-            )
-
-            if self.min_impurity_split < 0.0:
-                raise ValueError(
-                    "min_impurity_split must be greater than " "or equal to 0"
-                )
-        if self.min_impurity_decrease < 0.0:
-            raise ValueError(
-                "min_impurity_decrease must be greater than " "or equal to 0"
-            )
-        if self.max_leaf_nodes is not None:
-            if not isinstance(self.max_leaf_nodes, numbers.Integral):
-                raise ValueError(
-                    "max_leaf_nodes must be integral number but was "
-                    "%r" % self.max_leaf_nodes
-                )
-            if self.max_leaf_nodes < 2:
-                raise ValueError(
-                    ("max_leaf_nodes {0} must be either None " "or larger than 1").format(
-                        self.max_leaf_nodes
-                    )
-                )
-        if isinstance(self.max_bins, numbers.Integral):
-            if not 2 <= self.max_bins:
-                raise ValueError("max_bins must be at least 2, got %s" % self.max_bins)
-        else:
-            raise ValueError(
-                "max_bins must be integral number but was " "%r" % self.max_bins
-            )
-        if isinstance(self.min_bin_size, numbers.Integral):
-            if not 1 <= self.min_bin_size:
-                raise ValueError(
-                    "min_bin_size must be at least 1, got %s" % self.min_bin_size
-                )
-        else:
-            raise ValueError(
-                "min_bin_size must be integral number but was " "%r" % self.min_bin_size
-            )
-
     def _validate_targets(self, y, dtype):
         self.class_weight_ = None
         self.classes_ = None
@@ -342,25 +243,9 @@ def _fit(self, X, y, sample_weight):
                 self.oob_decision_function_ = from_table(
                     train_result.oob_err_decision_function
                 )
-                if xp.any(self.oob_decision_function_ == 0):
-                    warnings.warn(
-                        "Some inputs do not have OOB scores. This probably means "
-                        "too few trees were used to compute any reliable OOB "
-                        "estimates.",
-                        UserWarning,
-                    )
             else:
                 self.oob_score_ = from_table(train_result.oob_err_r2).item()
-                self.oob_prediction_ = from_table(
-                    train_result.oob_err_prediction
-                ).reshape(-1)
-                if np.any(self.oob_prediction_ == 0):
-                    warnings.warn(
-                        "Some inputs do not have OOB scores. This probably means "
-                        "too few trees were used to compute any reliable OOB "
-                        "estimates.",
-                        UserWarning,
-                    )
+                self.oob_prediction_ = from_table(train_result.oob_err_prediction)
 
         return self
 
@@ -563,7 +448,6 @@ def __init__(
         error_metric_mode="none",
         variable_importance_mode="none",
         algorithm="hist",
-        **kwargs,
     ):
         super().__init__(
             n_estimators=n_estimators,
@@ -641,7 +525,6 @@ def __init__(
         error_metric_mode="none",
         variable_importance_mode="none",
         algorithm="hist",
-        **kwargs,
     ):
         super().__init__(
             n_estimators=n_estimators,
@@ -732,7 +615,6 @@ def __init__(
         error_metric_mode="none",
         variable_importance_mode="none",
         algorithm="hist",
-        **kwargs,
     ):
         super().__init__(
             n_estimators=n_estimators,