Scarliles/honesty

asv_benchmarks/benchmarks/ensemble.py

@@ -2,15 +2,58 @@
     GradientBoostingClassifier,
     HistGradientBoostingClassifier,
     RandomForestClassifier,
+    RandomForestRegressor,
 )
 
 from .common import Benchmark, Estimator, Predictor
 from .datasets import (
     _20newsgroups_highdim_dataset,
     _20newsgroups_lowdim_dataset,
     _synth_classification_dataset,
+    _synth_regression_dataset,
+    _synth_regression_sparse_dataset,
 )
-from .utils import make_gen_classif_scorers
+from .utils import make_gen_classif_scorers, make_gen_reg_scorers
+
+
+class RandomForestRegressorBenchmark(Predictor, Estimator, Benchmark):
+    """
+    Benchmarks for RandomForestRegressor.
+    """
+
+    param_names = ["representation", "n_jobs"]
+    params = (["dense", "sparse"], Benchmark.n_jobs_vals)
+
+    def setup_cache(self):
+        super().setup_cache()
+
+    def make_data(self, params):
+        representation, n_jobs = params
+
+        if representation == "sparse":
+            data = _synth_regression_sparse_dataset()
+        else:
+            data = _synth_regression_dataset()
+
+        return data
+
+    def make_estimator(self, params):
+        representation, n_jobs = params
+
+        n_estimators = 500 if Benchmark.data_size == "large" else 100
+
+        estimator = RandomForestRegressor(
+            n_estimators=n_estimators,
+            min_samples_split=10,
+            max_features="log2",
+            n_jobs=n_jobs,
+            random_state=0,
+        )
+
+        return estimator
+
+    def make_scorers(self):
+        make_gen_reg_scorers(self)
 
 
 class RandomForestClassifierBenchmark(Predictor, Estimator, Benchmark):

sklearn/tree/_classes.py

@@ -88,6 +88,34 @@
 # =============================================================================
 
 
+class BuildTreeArgs:
+    def __init__(
+            self,
+            X,
+            y,
+            sample_weight,
+            missing_values_in_feature_mask,
+            min_samples_leaf,
+            min_weight_leaf,
+            max_leaf_nodes,
+            min_samples_split,
+            max_depth,
+            random_state,
+            classes
+    ):
+        self.X = X
+        self.y = y
+        self.sample_weight = sample_weight
+        self.missing_values_in_feature_mask = missing_values_in_feature_mask
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_leaf = min_weight_leaf
+        self.max_leaf_nodes = max_leaf_nodes
+        self.min_samples_split = min_samples_split
+        self.max_depth = max_depth
+        self.random_state = random_state
+        self.classes = classes
+
+
 class BaseDecisionTree(MultiOutputMixin, BaseEstimator, metaclass=ABCMeta):
     """Base class for decision trees.
 
@@ -155,6 +183,10 @@ def __init__(
         self.ccp_alpha = ccp_alpha
         self.store_leaf_values = store_leaf_values
         self.monotonic_cst = monotonic_cst
+        self.presplit_conditions = None
+        self.postsplit_conditions = None
+        self.splitter_listeners = None
+        self.tree_build_listeners = None
 
     def get_depth(self):
         """Return the depth of the decision tree.
@@ -228,7 +260,7 @@ def _compute_missing_values_in_feature_mask(self, X, estimator_name=None):
         missing_values_in_feature_mask = _any_isnan_axis0(X)
         return missing_values_in_feature_mask
 
-    def _fit(
+    def _prep_data(
         self,
         X,
         y,
@@ -405,8 +437,7 @@ def _fit(
             min_weight_leaf = self.min_weight_fraction_leaf * np.sum(sample_weight)
         self.min_weight_leaf_ = min_weight_leaf
 
-        # build the actual tree now with the parameters
-        self = self._build_tree(
+        return BuildTreeArgs(
             X=X,
             y=y,
             sample_weight=sample_weight,
@@ -417,9 +448,42 @@ def _fit(
             min_samples_split=min_samples_split,
             max_depth=max_depth,
             random_state=random_state,
+            classes=classes
+        )
+
+
+    def _fit(
+        self,
+        X,
+        y,
+        sample_weight=None,
+        check_input=True,
+        missing_values_in_feature_mask=None,
+        classes=None,
+    ):
+        bta = self._prep_data(
+            X=X,
+            y=y,
+            sample_weight=sample_weight,
+            check_input=check_input,
+            missing_values_in_feature_mask=missing_values_in_feature_mask,
+            classes=classes
+        )
+
+        # build the actual tree now with the parameters
+        return self._build_tree(
+            X=bta.X,
+            y=bta.y,
+            sample_weight=bta.sample_weight,
+            missing_values_in_feature_mask=bta.missing_values_in_feature_mask,
+            min_samples_leaf=bta.min_samples_leaf,
+            min_weight_leaf=bta.min_weight_leaf,
+            max_leaf_nodes=bta.max_leaf_nodes,
+            min_samples_split=bta.min_samples_split,
+            max_depth=bta.max_depth,
+            random_state=bta.random_state,
         )
 
-        return self
 
     def _build_tree(
         self,
@@ -523,6 +587,9 @@ def _build_tree(
                 min_weight_leaf,
                 random_state,
                 monotonic_cst,
+                presplit_conditions=self.presplit_conditions,
+                postsplit_conditions=self.postsplit_conditions,
+                listeners=self.splitter_listeners
             )
 
         if is_classifier(self):
@@ -545,6 +612,7 @@ def _build_tree(
                 max_depth,
                 self.min_impurity_decrease,
                 self.store_leaf_values,
+                listeners = self.tree_build_listeners
             )
         else:
             builder = BestFirstTreeBuilder(
@@ -556,6 +624,7 @@ def _build_tree(
                 max_leaf_nodes,
                 self.min_impurity_decrease,
                 self.store_leaf_values,
+                listeners = self.tree_build_listeners
             )
         builder.build(self.tree_, X, y, sample_weight, missing_values_in_feature_mask)
 

sklearn/tree/_events.pxd

@@ -0,0 +1,32 @@
+# Authors: Samuel Carliles <scarlil1@jhu.edu>
+#
+# License: BSD 3 clause
+
+# See _events.pyx for details.
+
+from libcpp.vector cimport vector
+from ..utils._typedefs cimport float32_t, float64_t, intp_t, int32_t, uint32_t
+
+ctypedef int EventType
+ctypedef void* EventHandlerEnv
+ctypedef void* EventData
+ctypedef bint (*EventHandlerFunction)(
+    EventType event_type,
+    EventHandlerEnv handler_env,
+    EventData event_data
+) noexcept nogil
+
+cdef struct EventHandlerClosure:
+    EventHandlerFunction f
+    EventHandlerEnv e
+
+cdef class EventHandler:
+    cdef public int[:] event_types
+    cdef EventHandlerClosure c
+
+cdef class NullHandler(EventHandler):
+    pass
+
+cdef class EventBroker:
+    cdef vector[vector[EventHandlerClosure]] listeners # listeners acts as a map from EventType to corresponding event handlers
+    cdef bint fire_event(self, EventType event_type, EventData event_data) noexcept nogil

sklearn/tree/_events.pyx

@@ -0,0 +1,61 @@
+
+# Authors: Samuel Carliles <scarlil1@jhu.edu>
+#
+# License: BSD 3 clause
+
+
+cdef class EventBroker:
+    def __cinit__(self, listeners: [EventHandler], event_types: [EventType]):
+        """
+        Parameters:
+        - listeners ([EventHandler])
+        - event_types ([EventType]): a list of EventTypes that may be fired by this EventBroker
+
+        Notes:
+        - Don't mix event types in a single EventBroker instance,
+          i.e. don't use the same EventBroker for brokering NodeSplitEvent that you use
+          for brokering TreeBuildEvent, etc
+        """
+        self.listeners.resize(max(event_types) + 1)
+
+        if(listeners is None):
+            for e in range(max(event_types) + 1):
+                self.listeners[e].resize(0)
+        else:
+            self.add_listeners(listeners, event_types)
+
+    def add_listeners(self, listeners: [EventHandler], event_types: [EventType]):
+        cdef int e, i, j, offset, mx, ct
+        cdef list l
+
+        # listeners is a vector of vectors which we index using EventType,
+        # so if event_types contains any EventType for which we don't already have a vector,
+        # its integer value will be larger than our current size + 1
+        mx = max(event_types)
+        offset = self.listeners.size()
+        if mx > offset + 1:
+            self.listeners.resize(mx + 1)
+
+        if(listeners is not None):
+            for e in event_types:
+                # find indices for all listeners to event type e
+                l = [j for j, _l in enumerate(listeners) if e in (<EventHandler>_l).event_types]
+                offset = self.listeners[e].size()
+                ct = len(l)
+                self.listeners[e].resize(offset + ct)
+                for i in range(ct):
+                    j = l[i]
+                    self.listeners[e][offset + i] = (<EventHandler>listeners[j]).c
+
+    cdef bint fire_event(self, EventType event_type, EventData event_data) noexcept nogil:
+        cdef bint result = True
+
+        #with gil:
+        #    print(f"firing event {event_type}")
+        #    print(f"listeners.size = {self.listeners.size()}")
+
+        if event_type < self.listeners.size():
+            for l in self.listeners[event_type]:
+                result = result and l.f(event_type, l.e, event_data)
+
+        return result