HoeffdingTreeClassifier¶
Hoeffding Tree or Very Fast Decision Tree classifier.
Parameters¶
-
grace_period (int) – defaults to
200Number of instances a leaf should observe between split attempts.
-
max_depth (int) – defaults to
NoneThe maximum depth a tree can reach. If
None, the tree will grow indefinitely. -
split_criterion (str) – defaults to
info_gainSplit criterion to use. - 'gini' - Gini - 'info_gain' - Information Gain - 'hellinger' - Helinger Distance
-
split_confidence (float) – defaults to
1e-07Allowed error in split decision, a value closer to 0 takes longer to decide.
-
tie_threshold (float) – defaults to
0.05Threshold below which a split will be forced to break ties.
-
leaf_prediction (str) – defaults to
nbaPrediction mechanism used at leafs. - 'mc' - Majority Class - 'nb' - Naive Bayes - 'nba' - Naive Bayes Adaptive
-
nb_threshold (int) – defaults to
0Number of instances a leaf should observe before allowing Naive Bayes.
-
nominal_attributes (list) – defaults to
NoneList of Nominal attributes identifiers. If empty, then assume that all numeric attributes should be treated as continuous.
-
splitter (river.tree.splitter.base.Splitter) – defaults to
NoneThe Splitter or Attribute Observer (AO) used to monitor the class statistics of numeric features and perform splits. Splitters are available in the
tree.splittermodule. Different splitters are available for classification and regression tasks. Classification and regression splitters can be distinguished by their propertyis_target_class. This is an advanced option. Special care must be taken when choosing different splitters. By default,tree.splitter.GaussianSplitteris used ifsplitterisNone. -
binary_split (bool) – defaults to
FalseIf True, only allow binary splits.
-
max_size (int) – defaults to
100The max size of the tree, in Megabytes (MB).
-
memory_estimate_period (int) – defaults to
1000000Interval (number of processed instances) between memory consumption checks.
-
stop_mem_management (bool) – defaults to
FalseIf True, stop growing as soon as memory limit is hit.
-
remove_poor_attrs (bool) – defaults to
FalseIf True, disable poor attributes to reduce memory usage.
-
merit_preprune (bool) – defaults to
TrueIf True, enable merit-based tree pre-pruning.
Attributes¶
-
height
-
leaf_prediction
Return the prediction strategy used by the tree at its leaves.
-
max_size
Max allowed size tree can reach (in MB).
-
n_active_leaves
-
n_branches
-
n_inactive_leaves
-
n_leaves
-
n_nodes
-
split_criterion
Return a string with the name of the split criterion being used by the tree.
-
summary
Collect metrics corresponding to the current status of the tree in a string buffer.
Examples¶
>>> from river import synth
>>> from river import evaluate
>>> from river import metrics
>>> from river import tree
>>> gen = synth.Agrawal(classification_function=0, seed=42)
>>> # Take 1000 instances from the infinite data generator
>>> dataset = iter(gen.take(1000))
>>> model = tree.HoeffdingTreeClassifier(
... grace_period=100,
... split_confidence=1e-5,
... nominal_attributes=['elevel', 'car', 'zipcode']
... )
>>> metric = metrics.Accuracy()
>>> evaluate.progressive_val_score(dataset, model, metric)
Accuracy: 83.78%
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.
debug_one
Print an explanation of how x is predicted.
Parameters
- x (dict)
Returns
typing.Union[str, NoneType]: A representation of the path followed by the tree to predict x; None if
draw
Draw the tree using the graphviz library.
Since the tree is drawn without passing incoming samples, classification trees will show the majority class in their leaves, whereas regression trees will use the target mean.
Parameters
- max_depth (int) – defaults to
None
The maximum depth a tree can reach. IfNone, the tree will grow indefinitely.
learn_one
Train the model on instance x and corresponding target y.
Parameters
- x
- y
- sample_weight – defaults to
1.0
Returns
self
predict_one
Predict the label of a set of features x.
Parameters
- x (dict)
Returns
typing.Union[bool, str, int]: The predicted label.
predict_proba_one
Predict the probability of each label for a dictionary of features x.
Parameters
- x
Returns
A dictionary that associates a probability which each label.
to_dataframe
Return a representation of the current tree structure organized in a pandas.DataFrame object.
In case the tree is empty or it only contains a single node (a leaf), None is returned.
Returns
df
Notes¶
A Hoeffding Tree 1 is an incremental, anytime decision tree induction algorithm that is capable of learning from massive data streams, assuming that the distribution generating examples does not change over time. Hoeffding trees exploit the fact that a small sample can often be enough to choose an optimal splitting attribute. This idea is supported mathematically by the Hoeffding bound, which quantifies the number of observations (in our case, examples) needed to estimate some statistics within a prescribed precision (in our case, the goodness of an attribute).
A theoretically appealing feature of Hoeffding Trees not shared by other incremental decision tree learners is that it has sound guarantees of performance. Using the Hoeffding bound one can show that its output is asymptotically nearly identical to that of a non-incremental learner using infinitely many examples. Implementation based on MOA 2.