SGTRegressor

Stochastic Gradient Tree for regression.

Incremental decision tree regressor that minimizes the mean square error to guide its growth.

Stochastic Gradient Trees (SGT) directly minimize a loss function to guide tree growth and update their predictions. Thus, they differ from other incrementally tree learners that do not directly optimize the loss, but a data impurity-related heuristic.

Parameters

• delta (float) – defaults to 1e-07

  Define the significance level of the F-tests performed to decide upon creating splits or updating predictions.

• grace_period (int) – defaults to 200

  Interval between split attempts or prediction updates.

• init_pred (float) – defaults to 0.0

  Initial value predicted by the tree.

• max_depth (Union[int, NoneType]) – defaults to None

  The maximum depth the tree might reach. If set to None, the trees will grow indefinitely.

• lambda_value (float) – defaults to 0.1

  Positive float value used to impose a penalty over the tree's predictions and force them to become smaller. The greater the lambda value, the more constrained are the predictions.

• gamma (float) – defaults to 1.0

  Positive float value used to impose a penalty over the tree's splits and force them to be avoided when possible. The greater the gamma value, the smaller the chance of a split occurring.

• nominal_attributes (Union[List, NoneType]) – defaults to None

  List with identifiers of the nominal attributes. If None, all features containing numbers are assumed to be numeric.

• feature_quantizer (river.tree.splitter.base.Quantizer) – defaults to None

  The algorithm used to quantize numeric features. Either a static quantizer (as in the original implementation) or a dynamic quantizer can be used. The correct choice and setup of the feature quantizer is a crucial step to determine the performance of SGTs. Feature quantizers are akin to the attribute observers used in Hoeffding Trees. By default, an instance of tree.splitter.StaticQuantizer (with default parameters) is used if this parameter is not set.

Attributes

• height

• n_branches

• n_leaves

• n_node_updates

• n_nodes

• n_observations

• n_splits

Examples

>>> from river import datasets
>>> from river import evaluate
>>> from river import metrics
>>> from river import tree

>>> dataset = datasets.TrumpApproval()
>>> model = tree.SGTRegressor(
...     delta=0.01,
...     lambda_value=0.01,
...     grace_period=20,
...     feature_quantizer=tree.splitter.DynamicQuantizer(std_prop=0.1)
... )
>>> metric = metrics.MAE()

>>> evaluate.progressive_val_score(dataset, model, metric)
MAE: 1.721818

Methods

clone

Return a fresh estimator with the same parameters.

The clone has the same parameters but has not been updated with any data. This works by looking at the parameters from the class signature. Each parameter is either - recursively cloned if it's a River classes. - deep-copied via copy.deepcopy if not. If the calling object is stochastic (i.e. it accepts a seed parameter) and has not been seeded, then the clone will not be idempotent. Indeed, this method's purpose if simply to return a new instance with the same input parameters.

learn_one

Fits to a set of features x and a real-valued target y.

Parameters

• x (dict)
• y (numbers.Number)
• w – defaults to 1.0

Returns

Regressor: self

predict_one

Predicts the target value of a set of features x.

Parameters

• x (dict)

Returns

Number: The prediction.

Notes

This implementation enhances the original proposal ¹ by using an incremental strategy to discretize numerical features dynamically, rather than relying on a calibration set and parameterized number of bins. The strategy used is an adaptation of the Quantization Observer (QO) ². Different bin size setting policies are available for selection. They directly related to number of split candidates the tree is going to explore, and thus, how accurate its split decisions are going to be. Besides, the number of stored bins per feature is directly related to the tree's memory usage and runtime.

References

---

1. Gouk, H., Pfahringer, B., & Frank, E. (2019, October). Stochastic Gradient Trees. In Asian Conference on Machine Learning (pp. 1094-1109). ↩

2. Mastelini, S.M. and de Leon Ferreira, A.C.P., 2021. Using dynamical quantization to perform split attempts in online tree regressors. Pattern Recognition Letters. ↩