# `HoeffdingTree`

### *class* capymoa.classifier.HoeffdingTree[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/classifier/_hoeffding_tree.py#L14)

Bases: [`MOAClassifier`](capymoa.base.MOAClassifier.md#capymoa.base.MOAClassifier)

Hoeffding Tree.

Hoeffding Tree (VFDT) <sup>[1](#id2)</sup> is a tree classifier classifier. A Hoeffding
tree 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.

```pycon
>>> from capymoa.classifier import HoeffdingTree
>>> from capymoa.datasets import ElectricityTiny
>>> from capymoa.evaluation import prequential_evaluation
>>>
>>> stream = ElectricityTiny()
>>> classifier = HoeffdingTree(stream.get_schema())
>>> results = prequential_evaluation(stream, classifier, max_instances=1000)
>>> print(f"{results['cumulative'].accuracy():.1f}")
84.4
```

* <a id='id2'>**[1]**</a> [G. Hulten, L. Spencer, and P. Domingos. Mining time-changing data streams. In KDD’01, pages 97–106, San Francisco, CA, 2001. ACM Press.](https://dl.acm.org/doi/10.1145/502512.502529)

#### \_\_init_\_(schema: [Schema](capymoa.stream.Schema.md#capymoa.stream.Schema) | [None](https://docs.python.org/3/builtins/constants.html#None) = None, random_seed: [int](https://docs.python.org/3/builtins/functions.html#int) = 0, grace_period: [int](https://docs.python.org/3/builtins/functions.html#int) = 200, split_criterion: [str](https://docs.python.org/3/builtins/stdtypes.html#str) | [SplitCriterion](capymoa.core.moa.splitcriteria.SplitCriterion.md#capymoa.core.moa.splitcriteria.SplitCriterion) = 'InfoGainSplitCriterion', confidence: [float](https://docs.python.org/3/builtins/functions.html#float) = 1e-3, tie_threshold: [float](https://docs.python.org/3/builtins/functions.html#float) = 0.05, leaf_prediction: [int](https://docs.python.org/3/builtins/functions.html#int) = 'NaiveBayesAdaptive', nb_threshold: [int](https://docs.python.org/3/builtins/functions.html#int) = 0, numeric_attribute_observer: [str](https://docs.python.org/3/builtins/stdtypes.html#str) = 'GaussianNumericAttributeClassObserver', binary_split: [bool](https://docs.python.org/3/builtins/functions.html#bool) = False, max_byte_size: [float](https://docs.python.org/3/builtins/functions.html#float) = 33554433, memory_estimate_period: [int](https://docs.python.org/3/builtins/functions.html#int) = 1000000, stop_mem_management: [bool](https://docs.python.org/3/builtins/functions.html#bool) = True, remove_poor_attrs: [bool](https://docs.python.org/3/builtins/functions.html#bool) = False, disable_prepruning: [bool](https://docs.python.org/3/builtins/functions.html#bool) = True)[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/classifier/_hoeffding_tree.py#L48)

Construct Hoeffding Tree.

* **Parameters:**
  * **schema** – Stream schema.
  * **random_seed** – Seed for reproducibility.
  * **grace_period** – Number of instances a leaf should observe between split
    attempts.
  * **split_criterion** – Split criterion to use.
  * **confidence** – Significance level to calculate the Hoeffding bound. The
    significance level is given by 1 - delta. Values closer to zero imply
    longer split decision delays.
  * **tie_threshold** – Threshold below which a split will be forced to break
    ties.
  * **leaf_prediction** – Prediction mechanism used at leafs.
  * **nb_threshold** – Number of instances a leaf should observe before allowing
    Naive Bayes.
  * **numeric_attribute_observer** – The Splitter or Attribute Observer (AO) used
    to monitor the class statistics of numeric features and perform splits.
  * **binary_split** – If True, only allow binary splits.
  * **max_byte_size** – The max size of the tree, in bytes.
  * **memory_estimate_period** – Interval (number of processed instances) between
    memory consumption checks.
  * **stop_mem_management** – If True, stop growing as soon as memory limit is
    hit.
  * **remove_poor_attrs** – If True, disable poor attributes to reduce memory
    usage.
  * **disable_prepruning** – If True, disable merit-based tree pre-pruning.

#### cli_help()[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_classifier.py#L111)

#### *classmethod* from_params(schema: [Any](https://docs.python.org/3/library/typing.html#typing.Any) = None, params: [dict](https://docs.python.org/3/builtins/stdtypes.html#dict)[[str](https://docs.python.org/3/builtins/stdtypes.html#str), [Any](https://docs.python.org/3/library/typing.html#typing.Any)] | [None](https://docs.python.org/3/builtins/constants.html#None) = None, random_seed: [int](https://docs.python.org/3/builtins/functions.html#int) = 1) → [Any](https://docs.python.org/3/library/typing.html#typing.Any)[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_learner_params.py#L170)

Construct an instance from parameters produced by `get_params`.

#### get_params() → [dict](https://docs.python.org/3/builtins/stdtypes.html#dict)[[str](https://docs.python.org/3/builtins/stdtypes.html#str), [Any](https://docs.python.org/3/library/typing.html#typing.Any)][[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_learner_params.py#L163)

Return the hyper-parameters captured from the constructor.

#### predict(instance: [Instance](capymoa.core.Instance.md#capymoa.core.Instance)) → [int](https://docs.python.org/3/builtins/functions.html#int) | [None](https://docs.python.org/3/builtins/constants.html#None)[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_classifier.py#L56)

Predict the label of an instance.

The base implementation calls [`predict_proba()`](#capymoa.classifier.HoeffdingTree.predict_proba) and returns the
label with the highest probability.

* **Parameters:**
  **instance** – The instance to predict the label for.
* **Returns:**
  The predicted label or `None` if the classifier is unable
  to make a prediction.

#### predict_proba(instance) → [ndarray](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray)[[tuple](https://docs.python.org/3/builtins/stdtypes.html#tuple)[[Any](https://docs.python.org/3/library/typing.html#typing.Any), ...], [dtype](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html#numpy.dtype)[float64]] | [None](https://docs.python.org/3/builtins/constants.html#None)[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_classifier.py#L117)

Return probability estimates for each label.

* **Parameters:**
  **instance** – The instance to estimate the probabilities for.
* **Returns:**
  An array of probabilities for each label or `None` if the
  classifier is unable to make a prediction.

#### train(instance)[[source]](https://github.com/adaptive-machine-learning/CapyMOA/blob/3e255b1/src/capymoa/base/_classifier.py#L114)

Train the classifier with a labeled instance.

* **Parameters:**
  **instance** – The labeled instance to train the classifier with.

#### random_seed *: [int](https://docs.python.org/3/builtins/functions.html#int)*

The random seed for reproducibility.

When implementing a classifier ensure random number generators are seeded.

#### schema *: [Schema](capymoa.stream.Schema.md#capymoa.stream.Schema)*

The schema representing the instances.