From d217d7805d9b8d87610ab85afc4325546f6db860 Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Thu, 16 Apr 2026 13:36:28 +0800 Subject: [PATCH 1/7] feat: add HoeffdingTree missing value policies --- docs/tutorials.rst | 1 + .../missing_value_policy_hoeffding_tree.ipynb | 350 ++++++++++++++++++ src/capymoa/classifier/_hoeffding_tree.py | 108 +++++- tests/test_classifiers.py | 23 ++ 4 files changed, 481 insertions(+), 1 deletion(-) create mode 100644 notebooks/missing_value_policy_hoeffding_tree.ipynb diff --git a/docs/tutorials.rst b/docs/tutorials.rst index 6deee3510..fa7318cc0 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -32,6 +32,7 @@ These tutorials will show you how to get started with the CapyMOA library. notebooks/save_and_load_model.ipynb notebooks/clustering.ipynb notebooks/feature_importance.ipynb + notebooks/missing_value_policy_hoeffding_tree.ipynb Talks ===== diff --git a/notebooks/missing_value_policy_hoeffding_tree.ipynb b/notebooks/missing_value_policy_hoeffding_tree.ipynb new file mode 100644 index 000000000..a091b78db --- /dev/null +++ b/notebooks/missing_value_policy_hoeffding_tree.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e2389de", + "metadata": {}, + "source": [ + "# HoeffdingTree Missing-Value Policy\n", + "\n", + "This notebook shows how `missing_value_policy` changes prediction in `HoeffdingTree`.\n", + "\n", + "Policies:\n", + "- `\"default\"`: use MOA's original prediction logic\n", + "- `\"random\"`: choose one child randomly when a split feature is missing\n", + "- `\"all\"`: follow all available children and combine their votes\n", + "\n", + "We use `ElectricityTiny()` and inject missing values into the prediction instances.\n", + "We summarize the comparison with accuracy and running-time tables.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8e889c4e", + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from capymoa.classifier import HoeffdingTree\n", + "from capymoa.datasets import ElectricityTiny\n", + "from capymoa.instance import Instance\n" + ] + }, + { + "cell_type": "markdown", + "id": "f19d8ed5", + "metadata": {}, + "source": [ + "## Helper Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "659a36a9", + "metadata": {}, + "outputs": [], + "source": [ + "def inject_missing_values(x, rng, missing_rate):\n", + " x_missing = x.copy().astype(float)\n", + " missing_mask = rng.random(x_missing.shape[0]) < missing_rate\n", + " x_missing[missing_mask] = np.nan\n", + " return x_missing\n", + "\n", + "\n", + "def evaluate_policy(policy, missing_rate, max_instances=1000, seed=7):\n", + " stream = ElectricityTiny()\n", + " schema = stream.get_schema()\n", + " learner = HoeffdingTree(\n", + " schema=schema,\n", + " random_seed=seed,\n", + " missing_value_policy=policy,\n", + " )\n", + " rng = np.random.default_rng(seed)\n", + "\n", + " correct = 0\n", + " total = 0\n", + " start = perf_counter()\n", + "\n", + " for i, instance in enumerate(stream):\n", + " if i >= max_instances:\n", + " break\n", + "\n", + " x_missing = inject_missing_values(instance.x, rng, missing_rate)\n", + " pred_instance = Instance.from_array(schema, x_missing)\n", + " prediction = learner.predict(pred_instance)\n", + "\n", + " if prediction is not None and prediction == instance.y_index:\n", + " correct += 1\n", + " total += 1\n", + "\n", + " learner.train(instance)\n", + "\n", + " return {\n", + " \"accuracy\": correct / total,\n", + " \"runtime_seconds\": perf_counter() - start,\n", + " }\n" + ] + }, + { + "cell_type": "markdown", + "id": "5cc1ac05", + "metadata": {}, + "source": [ + "## Run the Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "786adcfb", + "metadata": {}, + "outputs": [], + "source": [ + "rows = []\n", + "\n", + "for missing_rate in [0.0, 0.1, 0.3, 0.5, 0.7]:\n", + " for policy in [\"default\", \"random\", \"all\"]:\n", + " metrics = evaluate_policy(policy, missing_rate)\n", + " rows.append(\n", + " {\n", + " \"missing_rate\": missing_rate,\n", + " \"policy\": policy,\n", + " \"accuracy\": metrics[\"accuracy\"],\n", + " \"runtime_seconds\": metrics[\"runtime_seconds\"],\n", + " }\n", + " )\n", + "\n", + "results = pd.DataFrame(rows)\n", + "accuracy_table = results.pivot(index=\"missing_rate\", columns=\"policy\", values=\"accuracy\")\n", + "runtime_table = results.pivot(index=\"missing_rate\", columns=\"policy\", values=\"runtime_seconds\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "03bad092", + "metadata": {}, + "source": [ + "## Accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0c73fdda", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
policyalldefaultrandom
missing_rate
0.00.8230.8230.823
0.10.8040.8050.798
0.30.7410.7400.740
0.50.6850.6710.677
0.70.6280.6070.602
\n", + "
" + ], + "text/plain": [ + "policy all default random\n", + "missing_rate \n", + "0.0 0.823 0.823 0.823\n", + "0.1 0.804 0.805 0.798\n", + "0.3 0.741 0.740 0.740\n", + "0.5 0.685 0.671 0.677\n", + "0.7 0.628 0.607 0.602" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accuracy_table.round(3)\n" + ] + }, + { + "cell_type": "markdown", + "id": "870e763d", + "metadata": {}, + "source": [ + "## Runtime (seconds)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c5cd2319", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
policyalldefaultrandom
missing_rate
0.00.0380.0420.057
0.10.0570.0360.083
0.30.2500.0370.049
0.50.0640.0380.051
0.70.0560.0340.050
\n", + "
" + ], + "text/plain": [ + "policy all default random\n", + "missing_rate \n", + "0.0 0.038 0.042 0.057\n", + "0.1 0.057 0.036 0.083\n", + "0.3 0.250 0.037 0.049\n", + "0.5 0.064 0.038 0.051\n", + "0.7 0.056 0.034 0.050" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "runtime_table.round(3)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/capymoa/classifier/_hoeffding_tree.py b/src/capymoa/classifier/_hoeffding_tree.py index 89349323e..f7f4983bf 100644 --- a/src/capymoa/classifier/_hoeffding_tree.py +++ b/src/capymoa/classifier/_hoeffding_tree.py @@ -1,5 +1,7 @@ from __future__ import annotations -from typing import Union +from typing import Literal, Sequence, Union + +import numpy as np from capymoa.base import MOAClassifier from capymoa.splitcriteria import SplitCriterion, _split_criterion_to_cli_str @@ -8,6 +10,20 @@ import moa.classifiers.trees as moa_trees +MissingValuePolicy = Literal["default", "random", "all"] + + +def _validate_missing_value_policy( + policy: str, +) -> MissingValuePolicy: + valid_policies = ("default", "random", "all") + if policy not in valid_policies: + raise ValueError( + "Invalid value for missing_value_policy, valid options are " + "'default', 'random', or 'all'." + ) + return policy # type: ignore[return-value] + class HoeffdingTree(MOAClassifier): """Hoeffding Tree. @@ -60,6 +76,7 @@ def __init__( stop_mem_management: bool = True, remove_poor_attrs: bool = False, disable_prepruning: bool = True, + missing_value_policy: MissingValuePolicy = "default", ): """Construct Hoeffding Tree. @@ -87,7 +104,16 @@ def __init__( :param remove_poor_attrs: If True, disable poor attributes to reduce memory usage. :param disable_prepruning: If True, disable merit-based tree pre-pruning. + :param missing_value_policy: Prediction-time policy used when a + split attribute needed for traversal is missing. ``"default"`` + delegates to MOA's default behavior, ``"random"`` follows one + random child, and ``"all"`` combines votes from all reachable + children. """ + self.missing_value_policy = _validate_missing_value_policy( + missing_value_policy + ) + self._prediction_rng = np.random.default_rng(random_seed) mapping = { "grace_period": "-g", "max_byte_size": "-m", @@ -112,3 +138,83 @@ def __init__( CLI=config_str, random_seed=random_seed, ) + + def predict_proba(self, instance): + if ( + self.missing_value_policy == "default" + or not self._has_missing_features(instance) + ): + return super().predict_proba(instance) + + root = self.moa_learner.getTreeRoot() + if root is None: + return super().predict_proba(instance) + + votes = self._predict_votes_for_instance(instance.java_instance.getData(), root) + return self._normalize_votes(votes) + + @staticmethod + def _has_missing_features(instance) -> bool: + return bool(np.isnan(np.asarray(instance.x, dtype=float)).any()) + + @staticmethod + def _normalize_votes(votes: Sequence[float] | np.ndarray): + votes = np.asarray(votes, dtype=np.float64) + total = votes.sum() + if votes.size == 0 or total <= 1e-2 or np.isnan(total) or np.isinf(total): + return None + return votes / total + + def _predict_votes_for_instance(self, java_instance, node) -> np.ndarray: + if node is None: + return np.array([], dtype=np.float64) + + if node.isLeaf(): + return self._node_votes(node, java_instance) + + split_test = node.getSplitTest() + if not split_test.resultKnownForInstance(java_instance): + children = [ + node.getChild(child_idx) + for child_idx in range(node.numChildren()) + if node.getChild(child_idx) is not None + ] + if not children: + return self._node_votes(node, java_instance) + + if self.missing_value_policy == "random": + child_idx = int(self._prediction_rng.integers(len(children))) + return self._predict_votes_for_instance( + java_instance, children[child_idx] + ) + + return self._sum_votes( + [ + self._predict_votes_for_instance(java_instance, child) + for child in children + ] + ) + + child = node.getChild(split_test.branchForInstance(java_instance)) + if child is None: + return self._node_votes(node, java_instance) + + return self._predict_votes_for_instance(java_instance, child) + + def _node_votes(self, node, java_instance) -> np.ndarray: + return np.asarray( + node.getClassVotes(java_instance, self.moa_learner), dtype=np.float64 + ) + + @staticmethod + def _sum_votes(vote_arrays: Sequence[np.ndarray]) -> np.ndarray: + max_len = max((len(votes) for votes in vote_arrays), default=0) + if max_len == 0: + return np.array([], dtype=np.float64) + + combined = np.zeros(max_len, dtype=np.float64) + for votes in vote_arrays: + padded_votes = np.zeros(max_len, dtype=np.float64) + padded_votes[: len(votes)] = votes + combined += padded_votes + return combined diff --git a/tests/test_classifiers.py b/tests/test_classifiers.py index ed86a0940..8264bb7cd 100644 --- a/tests/test_classifiers.py +++ b/tests/test_classifiers.py @@ -253,6 +253,29 @@ class ClassifierTestCase: ] +def test_hoeffding_tree_accepts_missing_value_policy_parameter(): + stream = ElectricityTiny() + learner = HoeffdingTree( + schema=stream.get_schema(), + missing_value_policy="all", + ) + + assert learner.missing_value_policy == "all" + + +def test_hoeffding_tree_validates_missing_value_policy_parameter(): + stream = ElectricityTiny() + + with pytest.raises( + ValueError, + match="Invalid value for missing_value_policy", + ): + HoeffdingTree( + schema=stream.get_schema(), + missing_value_policy="not_a_strategy", + ) + + def _score(classifier: Classifier, stream: Stream, limit=100) -> float: """Eval without training the classifier.""" evaluator = ClassificationEvaluator(schema=stream.get_schema()) From af3f1d92d91a1ceeb1386ce6c14a83359945e3bf Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Thu, 16 Apr 2026 13:42:42 +0800 Subject: [PATCH 2/7] docs: refine missing value policy notebook --- notebooks/missing_value_policy_hoeffding_tree.ipynb | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/notebooks/missing_value_policy_hoeffding_tree.ipynb b/notebooks/missing_value_policy_hoeffding_tree.ipynb index a091b78db..3c17a3275 100644 --- a/notebooks/missing_value_policy_hoeffding_tree.ipynb +++ b/notebooks/missing_value_policy_hoeffding_tree.ipynb @@ -15,7 +15,13 @@ "- `\"all\"`: follow all available children and combine their votes\n", "\n", "We use `ElectricityTiny()` and inject missing values into the prediction instances.\n", - "We summarize the comparison with accuracy and running-time tables.\n" + "We summarize the comparison with accuracy and running-time tables.\n", + "\n", + "---\n", + "\n", + "*More information about CapyMOA can be found at* https://www.capymoa.org.\n", + "\n", + "**last update on 16/04/2026**" ] }, { From 7af4b452cfe3448310c02998a9aa7c268a3835f5 Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Thu, 23 Apr 2026 04:37:17 +0700 Subject: [PATCH 3/7] feat: enhance HoeffdingTree with visualization and prediction tracing --- .../missing_value_policy_hoeffding_tree.ipynb | 766 +++++++++++++----- src/capymoa/classifier/_hoeffding_tree.py | 152 +++- src/capymoa/visualization/__init__.py | 3 + src/capymoa/visualization/tree.py | 360 ++++++++ 4 files changed, 1060 insertions(+), 221 deletions(-) create mode 100644 src/capymoa/visualization/__init__.py create mode 100644 src/capymoa/visualization/tree.py diff --git a/notebooks/missing_value_policy_hoeffding_tree.ipynb b/notebooks/missing_value_policy_hoeffding_tree.ipynb index 3c17a3275..ce514a97b 100644 --- a/notebooks/missing_value_policy_hoeffding_tree.ipynb +++ b/notebooks/missing_value_policy_hoeffding_tree.ipynb @@ -2,48 +2,57 @@ "cells": [ { "cell_type": "markdown", - "id": "4e2389de", "metadata": {}, "source": [ - "# HoeffdingTree Missing-Value Policy\n", + "# HoeffdingTree Missing-Value Policies\n", "\n", - "This notebook shows how `missing_value_policy` changes prediction in `HoeffdingTree`.\n", + "This tutorial shows what `missing_value_policy` changes at prediction time.\n", "\n", - "Policies:\n", - "- `\"default\"`: use MOA's original prediction logic\n", - "- `\"random\"`: choose one child randomly when a split feature is missing\n", - "- `\"all\"`: follow all available children and combine their votes\n", + "The three options are:\n", "\n", - "We use `ElectricityTiny()` and inject missing values into the prediction instances.\n", - "We summarize the comparison with accuracy and running-time tables.\n", + "- `default`: use MOA's original prediction behavior\n", + "- `random`: when a split feature is missing, follow one random child\n", + "- `all`: when a split feature is missing, follow all available children and sum their votes\n", "\n", "---\n", "\n", "*More information about CapyMOA can be found at* https://www.capymoa.org.\n", "\n", - "**last update on 16/04/2026**" + "**last update on 23/04/2026**\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "8e889c4e", + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "from time import perf_counter\n", - "\n", "import numpy as np\n", "import pandas as pd\n", "\n", - "from capymoa.classifier import HoeffdingTree\n", - "from capymoa.datasets import ElectricityTiny\n", - "from capymoa.instance import Instance\n" + "from IPython.display import Markdown, display\n", + "\n", + "from capymoa.classifier._hoeffding_tree import HoeffdingTree\n", + "from capymoa.datasets import Electricity\n", + "from capymoa.instance import Instance\n", + "\n", + "try:\n", + " from graphviz import Source\n", + " GRAPHVIZ_AVAILABLE = True\n", + "except Exception:\n", + " GRAPHVIZ_AVAILABLE = False\n", + " Source = None\n" ] }, { "cell_type": "markdown", - "id": "f19d8ed5", "metadata": {}, "source": [ "## Helper Functions" @@ -51,98 +60,137 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "659a36a9", + "execution_count": 3, + "id": "31577b03", "metadata": {}, "outputs": [], "source": [ - "def inject_missing_values(x, rng, missing_rate):\n", - " x_missing = x.copy().astype(float)\n", - " missing_mask = rng.random(x_missing.shape[0]) < missing_rate\n", - " x_missing[missing_mask] = np.nan\n", - " return x_missing\n", + "def show_dot(dot):\n", + " if GRAPHVIZ_AVAILABLE:\n", + " display(Source(dot))\n", + " else:\n", + " display(Markdown(\"Graphviz is not available, so the DOT source is shown below.\"))\n", + " display(Markdown(\"```dot\\n\" + dot + \"\\n```\"))\n", + "\n", + "\n", + "def root_split_feature_index(model):\n", + " root = model.get_tree_root()\n", + " if root is None or root.isLeaf():\n", + " return 0\n", + "\n", + " split_test = root.getSplitTest()\n", + " try:\n", + " depends_on = list(split_test.getAttsTestDependsOn())\n", + " if depends_on:\n", + " return int(depends_on[0])\n", + " except Exception:\n", + " return 0\n", + "\n", + " return 0\n", + "\n", + "\n", + "def make_missing_instance(schema, base_instance, missing_index):\n", + " x = np.asarray(base_instance.x, dtype=float).copy()\n", + " x[missing_index] = np.nan\n", + "\n", + " instance = Instance.from_array(schema, x)\n", + " instance.java_instance.getData().setMissing(int(missing_index))\n", + " return instance\n", "\n", "\n", - "def evaluate_policy(policy, missing_rate, max_instances=1000, seed=7):\n", - " stream = ElectricityTiny()\n", - " schema = stream.get_schema()\n", - " learner = HoeffdingTree(\n", + "def train_model(policy, schema, training_instances=1000, seed=49):\n", + " stream = Electricity()\n", + " model = HoeffdingTree(\n", " schema=schema,\n", " random_seed=seed,\n", " missing_value_policy=policy,\n", " )\n", - " rng = np.random.default_rng(seed)\n", - "\n", - " correct = 0\n", - " total = 0\n", - " start = perf_counter()\n", "\n", " for i, instance in enumerate(stream):\n", - " if i >= max_instances:\n", + " if i >= training_instances:\n", " break\n", + " model.train(instance)\n", "\n", - " x_missing = inject_missing_values(instance.x, rng, missing_rate)\n", - " pred_instance = Instance.from_array(schema, x_missing)\n", - " prediction = learner.predict(pred_instance)\n", + " return model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train The Models\n", "\n", - " if prediction is not None and prediction == instance.y_index:\n", - " correct += 1\n", - " total += 1\n", + "All three models see the same stream. The only difference is how they handle missing values during prediction.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trained policies: ['default', 'random', 'all']\n" + ] + } + ], + "source": [ + "stream = Electricity()\n", + "schema = stream.get_schema()\n", + "base_instance = stream.next_instance()\n", "\n", - " learner.train(instance)\n", + "policies = [\"default\", \"random\", \"all\"]\n", + "models = {policy: train_model(policy, schema) for policy in policies}\n", "\n", - " return {\n", - " \"accuracy\": correct / total,\n", - " \"runtime_seconds\": perf_counter() - start,\n", - " }\n" + "print(\"trained policies:\", policies)\n" ] }, { "cell_type": "markdown", - "id": "5cc1ac05", "metadata": {}, "source": [ - "## Run the Comparison" + "## Create One Missing-Value Example\n", + "\n", + "We take one real instance and mark the root split feature as missing. If the tree has not split yet, the first feature is used.\n" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "786adcfb", + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "missing feature index: 3\n", + "x: [0. 1. 0. nan 0.439155 0.003467 0.422915 0.414912]\n", + "Java missing flag: True\n" + ] + } + ], "source": [ - "rows = []\n", + "missing_index = root_split_feature_index(models[\"default\"])\n", + "example = make_missing_instance(schema, base_instance, missing_index)\n", "\n", - "for missing_rate in [0.0, 0.1, 0.3, 0.5, 0.7]:\n", - " for policy in [\"default\", \"random\", \"all\"]:\n", - " metrics = evaluate_policy(policy, missing_rate)\n", - " rows.append(\n", - " {\n", - " \"missing_rate\": missing_rate,\n", - " \"policy\": policy,\n", - " \"accuracy\": metrics[\"accuracy\"],\n", - " \"runtime_seconds\": metrics[\"runtime_seconds\"],\n", - " }\n", - " )\n", - "\n", - "results = pd.DataFrame(rows)\n", - "accuracy_table = results.pivot(index=\"missing_rate\", columns=\"policy\", values=\"accuracy\")\n", - "runtime_table = results.pivot(index=\"missing_rate\", columns=\"policy\", values=\"runtime_seconds\")\n" + "print(\"missing feature index:\", missing_index)\n", + "print(\"x:\", example.x)\n", + "print(\"Java missing flag:\", example.java_instance.getData().isMissing(int(missing_index)))\n" ] }, { "cell_type": "markdown", - "id": "03bad092", "metadata": {}, "source": [ - "## Accuracy" + "## Compare Predictions" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "0c73fdda", + "execution_count": 6, + "id": "97e0329b", "metadata": {}, "outputs": [ { @@ -165,170 +213,504 @@ "\n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
policyalldefaultrandom
missing_ratepolicypredictionprobabilities
0.00.8230.8230.823
0.10.8040.8050.7980default1[0.455, 0.545]
0.30.7410.7400.7401random0[0.8149, 0.1851]
0.50.6850.6710.677
0.70.6280.6070.6022all1[0.0, 1.0]
\n", "" ], "text/plain": [ - "policy all default random\n", - "missing_rate \n", - "0.0 0.823 0.823 0.823\n", - "0.1 0.804 0.805 0.798\n", - "0.3 0.741 0.740 0.740\n", - "0.5 0.685 0.671 0.677\n", - "0.7 0.628 0.607 0.602" + " policy prediction probabilities\n", + "0 default 1 [0.455, 0.545]\n", + "1 random 0 [0.8149, 0.1851]\n", + "2 all 1 [0.0, 1.0]" ] }, - "execution_count": 9, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "accuracy_table.round(3)\n" + "rows = []\n", + "for policy, model in models.items():\n", + " proba = model.predict_proba(example)\n", + " prediction = int(np.argmax(proba)) if proba is not None else None\n", + "\n", + " rows.append(\n", + " {\n", + " \"policy\": policy,\n", + " \"prediction\": prediction,\n", + " \"probabilities\": None if proba is None else np.round(proba, 4).tolist(),\n", + " }\n", + " )\n", + "\n", + "pd.DataFrame(rows)\n" ] }, { "cell_type": "markdown", - "id": "870e763d", "metadata": {}, "source": [ - "## Runtime (seconds)" + "## Plot The Tree\n", + "\n", + "The highlighted path shows how each policy routes the same missing-value example through the learned tree. The `all` policy can highlight multiple branches when the missing feature is used in a split.\n" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "c5cd2319", + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
policyalldefaultrandom
missing_rate
0.00.0380.0420.057
0.10.0570.0360.083
0.30.2500.0370.049
0.50.0640.0380.051
0.70.0560.0340.050
\n", - "
" + "text/markdown": [ + "### Policy: `default`" ], "text/plain": [ - "policy all default random\n", - "missing_rate \n", - "0.0 0.038 0.042 0.057\n", - "0.1 0.057 0.036 0.083\n", - "0.3 0.250 0.037 0.049\n", - "0.5 0.064 0.038 0.051\n", - "0.7 0.056 0.034 0.050" + "" ] }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "RealHoeffdingTree\n", + "\n", + "HoeffdingTree missing-value policy: default\n", + "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", + "Prediction: DOWN | Proba: UP: 0.455, DOWN: 0.545\n", + "\n", + "\n", + "n0\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "fallback votes: UP: 182.00, DOWN: 218.00\n", + "predict: DOWN\n", + "\n", + "\n", + "\n", + "n1\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n0->n1\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n4\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "\n", + "\n", + "\n", + "n0->n4\n", + "\n", + "\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n2\n", + "\n", + "Leaf\n", + "votes: UP: 0.00, DOWN: 156.05\n", + "predict: DOWN\n", + "\n", + "\n", + "\n", + "n1->n2\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n3\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n1->n3\n", + "\n", + "\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n5\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n5\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "\n", + "\n", + "\n", + "n6\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n6\n", + "\n", + "\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Policy: `random`" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "RealHoeffdingTree\n", + "\n", + "HoeffdingTree missing-value policy: random\n", + "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", + "Prediction: UP | Proba: UP: 0.815, DOWN: 0.185\n", + "\n", + "\n", + "n0\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n1\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n0->n1\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n4\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "fallback votes: UP: 255.89, DOWN: 58.11\n", + "predict: UP\n", + "\n", + "\n", + "\n", + "n0->n4\n", + "\n", + "\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n2\n", + "\n", + "Leaf\n", + "votes: UP: 0.00, DOWN: 156.05\n", + "predict: DOWN\n", + "\n", + "\n", + "\n", + "n1->n2\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n3\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n1->n3\n", + "\n", + "\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n5\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n5\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "\n", + "\n", + "\n", + "n6\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n6\n", + "\n", + "\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Policy: `all`" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "RealHoeffdingTree\n", + "\n", + "HoeffdingTree missing-value policy: all\n", + "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", + "Prediction: DOWN | Proba: UP: 0.000, DOWN: 1.000\n", + "\n", + "\n", + "n0\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n1\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n0->n1\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n4\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "\n", + "\n", + "\n", + "n0->n4\n", + "\n", + "\n", + "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "\n", + "n2\n", + "\n", + "Leaf\n", + "votes: UP: 0.00, DOWN: 156.05\n", + "predict: DOWN\n", + "\n", + "\n", + "\n", + "n1->n2\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n3\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n1->n3\n", + "\n", + "\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "\n", + "\n", + "n5\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n5\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "\n", + "\n", + "\n", + "n6\n", + "\n", + "Leaf\n", + "votes: none\n", + "predict: none\n", + "\n", + "\n", + "\n", + "n4->n6\n", + "\n", + "\n", + "[att 4:nswprice] > 0.11904572727272728\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "runtime_table.round(3)\n" + "for policy in policies:\n", + " display(Markdown(f\"### Policy: `{policy}`\"))\n", + " dot = models[policy].export_tree_to_dot(\n", + " sample_instance=example,\n", + " title=f\"HoeffdingTree missing-value policy: {policy}\",\n", + " include_leaf_votes=True,\n", + " highlight_path=True,\n", + " )\n", + " show_dot(dot)\n" ] } ], @@ -348,7 +730,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11" + "version": "3.14.3" } }, "nbformat": 4, diff --git a/src/capymoa/classifier/_hoeffding_tree.py b/src/capymoa/classifier/_hoeffding_tree.py index f7f4983bf..e011a8fde 100644 --- a/src/capymoa/classifier/_hoeffding_tree.py +++ b/src/capymoa/classifier/_hoeffding_tree.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Literal, Sequence, Union +from dataclasses import dataclass +from typing import Any, Literal, Sequence, Union import numpy as np @@ -8,9 +9,22 @@ from capymoa.stream import Schema from capymoa._utils import build_cli_str_from_mapping_and_locals, _leaf_prediction +from capymoa.visualization import export_hoeffding_tree_to_dot + import moa.classifiers.trees as moa_trees MissingValuePolicy = Literal["default", "random", "all"] +TreeEdge = tuple[Any, int, Any] + + +@dataclass(frozen=True) +class TreePredictionTrace: + """Prediction votes and tree path used to produce them.""" + + votes: np.ndarray + vote_node: Any | None = None + nodes: tuple[Any, ...] = () + edges: tuple[TreeEdge, ...] = () def _validate_missing_value_policy( @@ -110,9 +124,7 @@ def __init__( random child, and ``"all"`` combines votes from all reachable children. """ - self.missing_value_policy = _validate_missing_value_policy( - missing_value_policy - ) + self.missing_value_policy = _validate_missing_value_policy(missing_value_policy) self._prediction_rng = np.random.default_rng(random_seed) mapping = { "grace_period": "-g", @@ -140,19 +152,40 @@ def __init__( ) def predict_proba(self, instance): - if ( - self.missing_value_policy == "default" - or not self._has_missing_features(instance) + if self.missing_value_policy == "default" or not self._has_missing_features( + instance ): return super().predict_proba(instance) - root = self.moa_learner.getTreeRoot() + root = self.get_tree_root() if root is None: return super().predict_proba(instance) - votes = self._predict_votes_for_instance(instance.java_instance.getData(), root) + votes = self.trace_prediction_path(instance.java_instance.getData(), root).votes return self._normalize_votes(votes) + def get_tree_root(self): + """Return the underlying real MOA tree root.""" + return self.moa_learner.getTreeRoot() + + def export_tree_to_dot( + self, + sample_instance=None, + title: str = "Real MOA Hoeffding Tree", + include_leaf_votes: bool = True, + highlight_path: bool = False, + require_missing_path: bool = False, + ) -> str: + """Export the learned real MOA tree to DOT.""" + return export_hoeffding_tree_to_dot( + self, + sample_instance=sample_instance, + title=title, + include_leaf_votes=include_leaf_votes, + highlight_path=highlight_path, + require_missing_path=require_missing_path, + ) + @staticmethod def _has_missing_features(instance) -> bool: return bool(np.isnan(np.asarray(instance.x, dtype=float)).any()) @@ -165,47 +198,108 @@ def _normalize_votes(votes: Sequence[float] | np.ndarray): return None return votes / total - def _predict_votes_for_instance(self, java_instance, node) -> np.ndarray: + def trace_prediction_path(self, java_instance, node=None) -> TreePredictionTrace: + """Return votes and tree path used by the missing-value prediction policy.""" if node is None: - return np.array([], dtype=np.float64) + node = self.get_tree_root() + return self._trace_prediction_path(java_instance, node) + + def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: + if node is None: + return TreePredictionTrace(votes=np.array([], dtype=np.float64)) if node.isLeaf(): - return self._node_votes(node, java_instance) + return TreePredictionTrace( + votes=self._node_votes(node, java_instance), + vote_node=node, + nodes=(node,), + ) split_test = node.getSplitTest() if not split_test.resultKnownForInstance(java_instance): - children = [ - node.getChild(child_idx) - for child_idx in range(node.numChildren()) - if node.getChild(child_idx) is not None - ] + if self.missing_value_policy == "default": + return TreePredictionTrace( + votes=self._node_votes(node, java_instance), + vote_node=node, + nodes=(node,), + ) + + children = [] + for child_idx in range(node.numChildren()): + child = node.getChild(child_idx) + if child is not None: + children.append((child_idx, child)) if not children: - return self._node_votes(node, java_instance) + return TreePredictionTrace( + votes=self._node_votes(node, java_instance), + vote_node=node, + nodes=(node,), + ) if self.missing_value_policy == "random": - child_idx = int(self._prediction_rng.integers(len(children))) - return self._predict_votes_for_instance( - java_instance, children[child_idx] + for pick_pos in self._prediction_rng.permutation(len(children)): + branch_idx, child = children[int(pick_pos)] + trace = self._trace_prediction_path(java_instance, child) + if self._has_usable_votes(trace.votes): + return TreePredictionTrace( + votes=trace.votes, + vote_node=trace.vote_node, + nodes=(node, *trace.nodes), + edges=((node, branch_idx, child), *trace.edges), + ) + return TreePredictionTrace( + votes=self._node_votes(node, java_instance), + vote_node=node, + nodes=(node,), ) - return self._sum_votes( - [ - self._predict_votes_for_instance(java_instance, child) - for child in children - ] + child_traces = [ + self._trace_prediction_path(java_instance, child) + for _, child in children + ] + edges = tuple( + (node, branch_idx, child) for branch_idx, child in children + ) + return TreePredictionTrace( + votes=self._sum_votes([trace.votes for trace in child_traces]), + vote_node=None, + nodes=(node, *(n for trace in child_traces for n in trace.nodes)), + edges=(*edges, *(e for trace in child_traces for e in trace.edges)), ) - child = node.getChild(split_test.branchForInstance(java_instance)) + branch_idx = int(split_test.branchForInstance(java_instance)) + child = node.getChild(branch_idx) if child is None: - return self._node_votes(node, java_instance) + return TreePredictionTrace( + votes=self._node_votes(node, java_instance), + vote_node=node, + nodes=(node,), + ) - return self._predict_votes_for_instance(java_instance, child) + trace = self._trace_prediction_path(java_instance, child) + return TreePredictionTrace( + votes=trace.votes, + vote_node=trace.vote_node, + nodes=(node, *trace.nodes), + edges=((node, branch_idx, child), *trace.edges), + ) def _node_votes(self, node, java_instance) -> np.ndarray: return np.asarray( node.getClassVotes(java_instance, self.moa_learner), dtype=np.float64 ) + @staticmethod + def _has_usable_votes(votes: Sequence[float] | np.ndarray) -> bool: + votes = np.asarray(votes, dtype=np.float64) + total = votes.sum() + return bool( + votes.size > 0 + and total > 1e-2 + and not np.isnan(total) + and not np.isinf(total) + ) + @staticmethod def _sum_votes(vote_arrays: Sequence[np.ndarray]) -> np.ndarray: max_len = max((len(votes) for votes in vote_arrays), default=0) diff --git a/src/capymoa/visualization/__init__.py b/src/capymoa/visualization/__init__.py new file mode 100644 index 000000000..5db1feaa9 --- /dev/null +++ b/src/capymoa/visualization/__init__.py @@ -0,0 +1,3 @@ +from .tree import export_hoeffding_tree_to_dot + +__all__ = ["export_hoeffding_tree_to_dot"] diff --git a/src/capymoa/visualization/tree.py b/src/capymoa/visualization/tree.py new file mode 100644 index 000000000..ec7294521 --- /dev/null +++ b/src/capymoa/visualization/tree.py @@ -0,0 +1,360 @@ +from __future__ import annotations + +import numpy as np +from java.lang import System # type: ignore + +from capymoa.stream import Schema + + +def dot_escape(value) -> str: + return str(value).replace("\\", "\\\\").replace('"', r"\"") + + +def _class_name(schema: Schema | None, index: int) -> str: + if schema is None: + return str(index) + try: + return str(schema.get_value_for_index(index)) + except Exception: + return str(index) + + +def _existing_children(node): + children = [] + for branch_idx in range(int(node.numChildren())): + child = node.getChild(branch_idx) + if child is not None: + children.append((branch_idx, child)) + return children + + +def _feature_name(schema: Schema | None, index: int) -> str: + if schema is None: + return f"x[{index}]" + + try: + return str(schema.get_moa_header().inputAttribute(index).name()) + except Exception: + return f"x[{index}]" + + +def _format_instance_text(model, sample_instance) -> str: + if sample_instance is None: + return "Incoming instance: none" + + values = np.asarray(sample_instance.x, dtype=float) + parts = [] + for idx, value in enumerate(values): + name = _feature_name(getattr(model, "schema", None), idx) + if np.isnan(value): + parts.append(f"{name} = ?") + else: + parts.append(f"{name} = {value:.3g}") + + return "Incoming instance: " + ", ".join(parts) + + +def _format_prediction_text(model, sample_instance, proba=None) -> str: + if sample_instance is None: + return "Prediction: none" + + if proba is None: + proba = model.predict_proba(sample_instance) + if proba is None: + return "Prediction: none" + + proba = np.asarray(proba, dtype=np.float64) + pred_idx = int(np.argmax(proba)) + pred_label = _class_name(model.schema, pred_idx) + proba_text = ", ".join( + f"{_class_name(model.schema, idx)}: {value:.3f}" + for idx, value in enumerate(proba) + ) + return f"Prediction: {pred_label} | Proba: {proba_text}" + + +def _branch_label(model, split_test, branch_idx: int) -> str: + try: + cond = split_test.describeConditionForBranch( + branch_idx, model.moa_learner.getModelContext() + ) + cond = str(cond) + if cond: + return cond + except Exception: + pass + return f"branch {branch_idx}" + + +def _split_node_label(model, node) -> str: + split_test = node.getSplitTest() + + try: + split_str = str(split_test) + if split_str: + return f"Split\n{split_str}" + except Exception: + pass + + branch_texts = [] + try: + for branch_idx in range(int(node.numChildren())): + cond = split_test.describeConditionForBranch( + branch_idx, model.moa_learner.getModelContext() + ) + branch_texts.append(str(cond)) + except Exception: + pass + + if branch_texts: + return "Split\n" + "\n".join(branch_texts) + + return "Split" + + +def _format_votes_text(model, votes, prefix: str) -> str: + votes = np.asarray(votes, dtype=np.float64) + if not model._has_usable_votes(votes): + return f"{prefix}: none\npredict: none" + + pred_idx = int(np.argmax(votes)) + pred_name = _class_name(model.schema, pred_idx) + parts = [ + f"{_class_name(model.schema, idx)}: {value:.2f}" + for idx, value in enumerate(votes) + ] + return f"{prefix}: {', '.join(parts)}\npredict: {pred_name}" + + +def _best_effort_leaf_votes_without_instance(node) -> np.ndarray: + try: + dist = node.observedClassDistribution + return np.asarray(list(dist.getArrayRef()), dtype=np.float64) + except Exception: + pass + + try: + dist = node.getObservedClassDistribution() + return np.asarray(list(dist.getArrayRef()), dtype=np.float64) + except Exception: + pass + + return np.array([], dtype=np.float64) + + +def _leaf_dot_label(model, node, java_instance, include_votes: bool) -> str: + if java_instance is None: + votes = _best_effort_leaf_votes_without_instance(node) + else: + votes = model._node_votes(node, java_instance) + + if not include_votes: + votes = np.asarray(votes, dtype=np.float64) + if not model._has_usable_votes(votes): + return "Leaf\npredict: none" + pred_idx = int(np.argmax(votes)) + pred_name = _class_name(model.schema, pred_idx) + return f"Leaf\npredict: {pred_name}" + + return "Leaf\n" + _format_votes_text(model, votes, "votes") + + +def _node_key(node) -> int: + return int(System.identityHashCode(node)) + + +def _trace_node_keys(trace) -> set[int]: + return {_node_key(node) for node in trace.nodes} + + +def _trace_edge_keys(trace) -> set[tuple[int, int, int]]: + return { + (_node_key(parent), branch_idx, _node_key(child)) + for parent, branch_idx, child in trace.edges + } + + +def _trace_vote_node_key(trace) -> int | None: + if trace.vote_node is None: + return None + return _node_key(trace.vote_node) + + +def _copy_rng_state(model): + rng = getattr(model, "_prediction_rng", None) + if rng is None: + return None + return rng.bit_generator.state.copy() + + +def instance_triggers_missing_value_path(model, sample_instance, node=None) -> bool: + if sample_instance is None: + return False + + if node is None: + node = model.get_tree_root() + + if node is None or node.isLeaf(): + return False + + return _subtree_triggers_missing_value_path( + java_instance=sample_instance.java_instance.getData(), + node=node, + ) + + +def _subtree_triggers_missing_value_path(java_instance, node) -> bool: + if node is None or node.isLeaf(): + return False + + split_test = node.getSplitTest() + try: + if not bool(split_test.resultKnownForInstance(java_instance)): + return True + except Exception: + return False + + try: + child = node.getChild(int(split_test.branchForInstance(java_instance))) + except Exception: + return False + + if child is None: + return False + + return _subtree_triggers_missing_value_path( + java_instance=java_instance, + node=child, + ) + + +def export_hoeffding_tree_to_dot( + model, + sample_instance=None, + title: str = "Real MOA Hoeffding Tree", + include_leaf_votes: bool = True, + highlight_path: bool = False, + require_missing_path: bool = False, +) -> str: + root = model.get_tree_root() + if root is None: + return 'digraph RealHoeffdingTree { empty [label="Tree is empty"]; }' + + java_instance = None + if sample_instance is not None: + java_instance = sample_instance.java_instance.getData() + + if require_missing_path and not instance_triggers_missing_value_path( + model, sample_instance, root + ): + raise ValueError( + "sample_instance does not trigger missing-value handling on the tree path." + ) + + rng_state = _copy_rng_state(model) + + active_nodes = set() + active_edges = set() + traced_proba = None + trace_vote_node = None + traced_votes = None + if highlight_path and java_instance is not None: + trace = model.trace_prediction_path(java_instance, root) + active_nodes = _trace_node_keys(trace) + active_edges = _trace_edge_keys(trace) + trace_vote_node = _trace_vote_node_key(trace) + traced_votes = trace.votes + if model.missing_value_policy != "default": + traced_proba = model._normalize_votes(trace.votes) + + if rng_state is not None: + model._prediction_rng.bit_generator.state = rng_state.copy() + + instance_text = _format_instance_text(model, sample_instance) + prediction_text = _format_prediction_text( + model, sample_instance, proba=traced_proba + ) + if rng_state is not None: + model._prediction_rng.bit_generator.state = rng_state.copy() + + graph_label = f"{title}\n{instance_text}\n{prediction_text}" + + lines = [ + "digraph RealHoeffdingTree {", + f' graph [rankdir=TB, labelloc=t, fontsize=18, label="{dot_escape(graph_label)}"];', + ' node [shape=box, style="rounded,filled", fontname="Helvetica", fontsize=11];', + ' edge [fontname="Helvetica", fontsize=10];', + ] + + visited = {} + counter = {"value": 0} + + def next_id(): + node_id = f"n{counter['value']}" + counter["value"] += 1 + return node_id + + def style_node(node_obj, is_leaf: bool) -> str: + if _node_key(node_obj) in active_nodes: + return 'fillcolor="#dbeafe", color="#1d4ed8", penwidth=2' + if is_leaf: + return 'fillcolor="#f0fdf4", color="#16a34a"' + return 'fillcolor="#f8fafc", color="#94a3b8"' + + def style_edge(edge_key) -> str: + if edge_key in active_edges: + return 'color="#1d4ed8", penwidth=2' + return 'color="#94a3b8", style="dashed"' + + def walk(node): + node_key = _node_key(node) + if node_key in visited: + return visited[node_key] + + node_id = next_id() + visited[node_key] = node_id + + is_leaf = bool(node.isLeaf()) + + if is_leaf: + label = _leaf_dot_label( + model=model, + node=node, + java_instance=java_instance, + include_votes=include_leaf_votes, + ) + lines.append( + f' {node_id} [label="{dot_escape(label)}", {style_node(node, True)}];' + ) + return node_id + + split_label = _split_node_label(model, node) + if ( + include_leaf_votes + and trace_vote_node is not None + and trace_vote_node == _node_key(node) + and traced_votes is not None + ): + split_label += "\n" + _format_votes_text( + model, traced_votes, "fallback votes" + ) + lines.append( + f' {node_id} [label="{dot_escape(split_label)}", {style_node(node, False)}];' + ) + + split_test = node.getSplitTest() + + for branch_idx, child in _existing_children(node): + child_id = walk(child) + edge_label = _branch_label(model, split_test, branch_idx) + edge_key = (_node_key(node), branch_idx, _node_key(child)) + + lines.append( + f' {node_id} -> {child_id} [label="{dot_escape(edge_label)}", {style_edge(edge_key)}];' + ) + + return node_id + + walk(root) + lines.append("}") + return "\n".join(lines) From da3e72ad18f54f837d71e2d3bf4caaf367b9c023 Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Fri, 24 Apr 2026 00:10:15 +0700 Subject: [PATCH 4/7] fix: update HoeffdingTree to improve missing value handling and enhance visualization features --- .../missing_value_policy_hoeffding_tree.ipynb | 139 ++++++++++-------- src/capymoa/classifier/_hoeffding_tree.py | 50 +++---- src/capymoa/visualization/tree.py | 48 +++--- 3 files changed, 119 insertions(+), 118 deletions(-) diff --git a/notebooks/missing_value_policy_hoeffding_tree.ipynb b/notebooks/missing_value_policy_hoeffding_tree.ipynb index ce514a97b..694da693d 100644 --- a/notebooks/missing_value_policy_hoeffding_tree.ipynb +++ b/notebooks/missing_value_policy_hoeffding_tree.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "6ba696d6", "metadata": {}, "source": [ "# HoeffdingTree Missing-Value Policies\n", @@ -11,18 +12,22 @@ "The three options are:\n", "\n", "- `default`: use MOA's original prediction behavior\n", - "- `random`: when a split feature is missing, follow one random child\n", + "- `random`: when a split feature is missing, follow one randomly chosen child\n", "- `all`: when a split feature is missing, follow all available children and sum their votes\n", "\n", + "The tree plot renders the full learned tree. Highlighted nodes and edges show the traced prediction path, and any internal node that supplies fallback votes is labeled with `fallback votes`.\n", + "\n", "---\n", "\n", "*More information about CapyMOA can be found at* https://www.capymoa.org.\n", "\n", - "**last update on 23/04/2026**\n" + "**last update on 24/04/2026**\n", + "\n" ] }, { "cell_type": "markdown", + "id": "c3164799", "metadata": {}, "source": [ "## Imports" @@ -30,7 +35,8 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, + "id": "e42247c1", "metadata": {}, "outputs": [], "source": [ @@ -39,7 +45,7 @@ "\n", "from IPython.display import Markdown, display\n", "\n", - "from capymoa.classifier._hoeffding_tree import HoeffdingTree\n", + "from capymoa.classifier import HoeffdingTree\n", "from capymoa.datasets import Electricity\n", "from capymoa.instance import Instance\n", "\n", @@ -48,11 +54,12 @@ " GRAPHVIZ_AVAILABLE = True\n", "except Exception:\n", " GRAPHVIZ_AVAILABLE = False\n", - " Source = None\n" + " Source = None" ] }, { "cell_type": "markdown", + "id": "a6f98601", "metadata": {}, "source": [ "## Helper Functions" @@ -60,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "31577b03", "metadata": {}, "outputs": [], @@ -111,11 +118,12 @@ " break\n", " model.train(instance)\n", "\n", - " return model\n" + " return model" ] }, { "cell_type": "markdown", + "id": "3d7d69ce", "metadata": {}, "source": [ "## Train The Models\n", @@ -125,7 +133,8 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "id": "df635684", "metadata": {}, "outputs": [ { @@ -144,11 +153,12 @@ "policies = [\"default\", \"random\", \"all\"]\n", "models = {policy: train_model(policy, schema) for policy in policies}\n", "\n", - "print(\"trained policies:\", policies)\n" + "print(\"trained policies:\", policies)" ] }, { "cell_type": "markdown", + "id": "b8c2e506", "metadata": {}, "source": [ "## Create One Missing-Value Example\n", @@ -158,14 +168,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, + "id": "275543a3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "missing feature index: 3\n", + "Missing feature index: 3\n", "x: [0. 1. 0. nan 0.439155 0.003467 0.422915 0.414912]\n", "Java missing flag: True\n" ] @@ -175,13 +186,14 @@ "missing_index = root_split_feature_index(models[\"default\"])\n", "example = make_missing_instance(schema, base_instance, missing_index)\n", "\n", - "print(\"missing feature index:\", missing_index)\n", + "print(\"Missing feature index:\", missing_index)\n", "print(\"x:\", example.x)\n", - "print(\"Java missing flag:\", example.java_instance.getData().isMissing(int(missing_index)))\n" + "print(\"Java missing flag:\", example.java_instance.getData().isMissing(int(missing_index)))" ] }, { "cell_type": "markdown", + "id": "be768ec9", "metadata": {}, "source": [ "## Compare Predictions" @@ -189,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "97e0329b", "metadata": {}, "outputs": [ @@ -229,8 +241,8 @@ " \n", " 1\n", " random\n", - " 0\n", - " [0.8149, 0.1851]\n", + " 1\n", + " [0.0, 1.0]\n", " \n", " \n", " 2\n", @@ -243,13 +255,13 @@ "" ], "text/plain": [ - " policy prediction probabilities\n", - "0 default 1 [0.455, 0.545]\n", - "1 random 0 [0.8149, 0.1851]\n", - "2 all 1 [0.0, 1.0]" + " policy prediction probabilities\n", + "0 default 1 [0.455, 0.545]\n", + "1 random 1 [0.0, 1.0]\n", + "2 all 1 [0.0, 1.0]" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -268,21 +280,24 @@ " }\n", " )\n", "\n", - "pd.DataFrame(rows)\n" + "pd.DataFrame(rows)" ] }, { "cell_type": "markdown", + "id": "800dc255", "metadata": {}, "source": [ "## Plot The Tree\n", "\n", - "The highlighted path shows how each policy routes the same missing-value example through the learned tree. The `all` policy can highlight multiple branches when the missing feature is used in a split.\n" + "The highlighted path shows how each policy routes the same missing-value example through the learned tree. The full tree is rendered; highlighting only marks the path used for prediction. The `all` policy can highlight multiple branches. If a split node supplies fallback votes, the node label shows `fallback votes`.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, + "id": "a3ef5966", "metadata": {}, "outputs": [ { @@ -305,11 +320,11 @@ " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n", "\n", - "\n", + "\n", "\n", "\n", - "RealHoeffdingTree\n", + "HoeffdingTree\n", "\n", "HoeffdingTree missing-value policy: default\n", "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", @@ -418,7 +433,7 @@ "\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -444,54 +459,54 @@ " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n", "\n", - "\n", + "\n", "\n", "\n", - "RealHoeffdingTree\n", + "HoeffdingTree\n", "\n", "HoeffdingTree missing-value policy: random\n", "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", - "Prediction: UP | Proba: UP: 0.815, DOWN: 0.185\n", + "Prediction: DOWN | Proba: UP: 0.214, DOWN: 0.786\n", "\n", "\n", "n0\n", - "\n", - "Split\n", - "[att 4:nswprice] <= 0.08667045454545455\n", - "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.08667045454545455\n", + "[att 4:nswprice] > 0.08667045454545455\n", "\n", "\n", "\n", "n1\n", - "\n", - "Split\n", - "[att 4:nswprice] <= 0.07824736363636364\n", - "[att 4:nswprice] > 0.07824736363636364\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.07824736363636364\n", + "[att 4:nswprice] > 0.07824736363636364\n", + "fallback votes: UP: 104.11, DOWN: 381.89\n", + "predict: DOWN\n", "\n", "\n", "\n", "n0->n1\n", - "\n", - "\n", - "[att 4:nswprice] <= 0.08667045454545455\n", + "\n", + "\n", + "[att 4:nswprice] <= 0.08667045454545455\n", "\n", "\n", "\n", "n4\n", - "\n", - "Split\n", - "[att 4:nswprice] <= 0.11904572727272728\n", - "[att 4:nswprice] > 0.11904572727272728\n", - "fallback votes: UP: 255.89, DOWN: 58.11\n", - "predict: UP\n", + "\n", + "Split\n", + "[att 4:nswprice] <= 0.11904572727272728\n", + "[att 4:nswprice] > 0.11904572727272728\n", "\n", "\n", "\n", "n0->n4\n", - "\n", - "\n", - "[att 4:nswprice] > 0.08667045454545455\n", + "\n", + "\n", + "[att 4:nswprice] > 0.08667045454545455\n", "\n", "\n", "\n", @@ -504,7 +519,7 @@ "\n", "\n", "n1->n2\n", - "\n", + "\n", "\n", "[att 4:nswprice] <= 0.07824736363636364\n", "\n", @@ -519,8 +534,8 @@ "\n", "\n", "n1->n3\n", - "\n", - "\n", + "\n", + "\n", "[att 4:nswprice] > 0.07824736363636364\n", "\n", "\n", @@ -534,8 +549,8 @@ "\n", "\n", "n4->n5\n", - "\n", - "\n", + "\n", + "\n", "[att 4:nswprice] <= 0.11904572727272728\n", "\n", "\n", @@ -549,15 +564,15 @@ "\n", "\n", "n4->n6\n", - "\n", - "\n", + "\n", + "\n", "[att 4:nswprice] > 0.11904572727272728\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -583,11 +598,11 @@ " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n", "\n", - "\n", + "\n", "\n", "\n", - "RealHoeffdingTree\n", + "HoeffdingTree\n", "\n", "HoeffdingTree missing-value policy: all\n", "Incoming instance: date = 0, day = 1, period = 0, nswprice = ?, nswdemand = 0.439, vicprice = 0.00347, vicdemand = 0.423, transfer = 0.415\n", @@ -694,7 +709,7 @@ "\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -710,7 +725,7 @@ " include_leaf_votes=True,\n", " highlight_path=True,\n", " )\n", - " show_dot(dot)\n" + " show_dot(dot)" ] } ], diff --git a/src/capymoa/classifier/_hoeffding_tree.py b/src/capymoa/classifier/_hoeffding_tree.py index e011a8fde..1887eab59 100644 --- a/src/capymoa/classifier/_hoeffding_tree.py +++ b/src/capymoa/classifier/_hoeffding_tree.py @@ -1,20 +1,20 @@ from __future__ import annotations + from dataclasses import dataclass from typing import Any, Literal, Sequence, Union import numpy as np +from capymoa._utils import build_cli_str_from_mapping_and_locals, _leaf_prediction from capymoa.base import MOAClassifier from capymoa.splitcriteria import SplitCriterion, _split_criterion_to_cli_str from capymoa.stream import Schema -from capymoa._utils import build_cli_str_from_mapping_and_locals, _leaf_prediction - from capymoa.visualization import export_hoeffding_tree_to_dot import moa.classifiers.trees as moa_trees MissingValuePolicy = Literal["default", "random", "all"] -TreeEdge = tuple[Any, int, Any] +TreeTraceEdge = tuple[Any, int, Any] @dataclass(frozen=True) @@ -22,9 +22,9 @@ class TreePredictionTrace: """Prediction votes and tree path used to produce them.""" votes: np.ndarray - vote_node: Any | None = None + vote_source_node: Any | None = None nodes: tuple[Any, ...] = () - edges: tuple[TreeEdge, ...] = () + edges: tuple[TreeTraceEdge, ...] = () def _validate_missing_value_policy( @@ -121,11 +121,11 @@ def __init__( :param missing_value_policy: Prediction-time policy used when a split attribute needed for traversal is missing. ``"default"`` delegates to MOA's default behavior, ``"random"`` follows one - random child, and ``"all"`` combines votes from all reachable - children. + randomly chosen child and falls back to the current node if that + path does not produce usable votes, and ``"all"`` combines votes + from all reachable children. """ self.missing_value_policy = _validate_missing_value_policy(missing_value_policy) - self._prediction_rng = np.random.default_rng(random_seed) mapping = { "grace_period": "-g", "max_byte_size": "-m", @@ -211,7 +211,7 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: if node.isLeaf(): return TreePredictionTrace( votes=self._node_votes(node, java_instance), - vote_node=node, + vote_source_node=node, nodes=(node,), ) @@ -220,7 +220,7 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: if self.missing_value_policy == "default": return TreePredictionTrace( votes=self._node_votes(node, java_instance), - vote_node=node, + vote_source_node=node, nodes=(node,), ) @@ -232,24 +232,24 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: if not children: return TreePredictionTrace( votes=self._node_votes(node, java_instance), - vote_node=node, + vote_source_node=node, nodes=(node,), ) if self.missing_value_policy == "random": - for pick_pos in self._prediction_rng.permutation(len(children)): - branch_idx, child = children[int(pick_pos)] - trace = self._trace_prediction_path(java_instance, child) - if self._has_usable_votes(trace.votes): - return TreePredictionTrace( - votes=trace.votes, - vote_node=trace.vote_node, - nodes=(node, *trace.nodes), - edges=((node, branch_idx, child), *trace.edges), - ) + pick_pos = int(np.random.randint(len(children))) + branch_idx, child = children[pick_pos] + trace = self._trace_prediction_path(java_instance, child) + if self._has_usable_votes(trace.votes): + return TreePredictionTrace( + votes=trace.votes, + vote_source_node=trace.vote_source_node, + nodes=(node, *trace.nodes), + edges=((node, branch_idx, child), *trace.edges), + ) return TreePredictionTrace( votes=self._node_votes(node, java_instance), - vote_node=node, + vote_source_node=node, nodes=(node,), ) @@ -262,7 +262,7 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: ) return TreePredictionTrace( votes=self._sum_votes([trace.votes for trace in child_traces]), - vote_node=None, + vote_source_node=None, nodes=(node, *(n for trace in child_traces for n in trace.nodes)), edges=(*edges, *(e for trace in child_traces for e in trace.edges)), ) @@ -272,14 +272,14 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: if child is None: return TreePredictionTrace( votes=self._node_votes(node, java_instance), - vote_node=node, + vote_source_node=node, nodes=(node,), ) trace = self._trace_prediction_path(java_instance, child) return TreePredictionTrace( votes=trace.votes, - vote_node=trace.vote_node, + vote_source_node=trace.vote_source_node, nodes=(node, *trace.nodes), edges=((node, branch_idx, child), *trace.edges), ) diff --git a/src/capymoa/visualization/tree.py b/src/capymoa/visualization/tree.py index ec7294521..e2c9bbc41 100644 --- a/src/capymoa/visualization/tree.py +++ b/src/capymoa/visualization/tree.py @@ -174,17 +174,10 @@ def _trace_edge_keys(trace) -> set[tuple[int, int, int]]: } -def _trace_vote_node_key(trace) -> int | None: - if trace.vote_node is None: +def _trace_vote_source_node_key(trace) -> int | None: + if trace.vote_source_node is None: return None - return _node_key(trace.vote_node) - - -def _copy_rng_state(model): - rng = getattr(model, "_prediction_rng", None) - if rng is None: - return None - return rng.bit_generator.state.copy() + return _node_key(trace.vote_source_node) def instance_triggers_missing_value_path(model, sample_instance, node=None) -> bool: @@ -231,14 +224,14 @@ def _subtree_triggers_missing_value_path(java_instance, node) -> bool: def export_hoeffding_tree_to_dot( model, sample_instance=None, - title: str = "Real MOA Hoeffding Tree", + title: str = "Hoeffding Tree", include_leaf_votes: bool = True, highlight_path: bool = False, require_missing_path: bool = False, ) -> str: root = model.get_tree_root() if root is None: - return 'digraph RealHoeffdingTree { empty [label="Tree is empty"]; }' + return 'digraph HoeffdingTree { empty [label="Tree is empty"]; }' java_instance = None if sample_instance is not None: @@ -251,36 +244,29 @@ def export_hoeffding_tree_to_dot( "sample_instance does not trigger missing-value handling on the tree path." ) - rng_state = _copy_rng_state(model) - active_nodes = set() active_edges = set() - traced_proba = None - trace_vote_node = None - traced_votes = None + trace_proba = None + trace_vote_source_node_key = None + trace_votes = None if highlight_path and java_instance is not None: trace = model.trace_prediction_path(java_instance, root) active_nodes = _trace_node_keys(trace) active_edges = _trace_edge_keys(trace) - trace_vote_node = _trace_vote_node_key(trace) - traced_votes = trace.votes + trace_vote_source_node_key = _trace_vote_source_node_key(trace) + trace_votes = trace.votes if model.missing_value_policy != "default": - traced_proba = model._normalize_votes(trace.votes) - - if rng_state is not None: - model._prediction_rng.bit_generator.state = rng_state.copy() + trace_proba = model._normalize_votes(trace.votes) instance_text = _format_instance_text(model, sample_instance) prediction_text = _format_prediction_text( - model, sample_instance, proba=traced_proba + model, sample_instance, proba=trace_proba ) - if rng_state is not None: - model._prediction_rng.bit_generator.state = rng_state.copy() graph_label = f"{title}\n{instance_text}\n{prediction_text}" lines = [ - "digraph RealHoeffdingTree {", + "digraph HoeffdingTree {", f' graph [rankdir=TB, labelloc=t, fontsize=18, label="{dot_escape(graph_label)}"];', ' node [shape=box, style="rounded,filled", fontname="Helvetica", fontsize=11];', ' edge [fontname="Helvetica", fontsize=10];', @@ -331,12 +317,12 @@ def walk(node): split_label = _split_node_label(model, node) if ( include_leaf_votes - and trace_vote_node is not None - and trace_vote_node == _node_key(node) - and traced_votes is not None + and trace_vote_source_node_key is not None + and trace_vote_source_node_key == _node_key(node) + and trace_votes is not None ): split_label += "\n" + _format_votes_text( - model, traced_votes, "fallback votes" + model, trace_votes, "fallback votes" ) lines.append( f' {node_id} [label="{dot_escape(split_label)}", {style_node(node, False)}];' From 6e617b883c0d6db21d37afbbff60c95c9f6c22c8 Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Fri, 24 Apr 2026 01:05:37 +0700 Subject: [PATCH 5/7] docs: add notebook for HoeffdingTree missing-value policy experiments --- .../missing_value_policy_experiments.ipynb | 1036 +++++++++++++++++ 1 file changed, 1036 insertions(+) create mode 100644 notebooks/missing_value_policy_experiments.ipynb diff --git a/notebooks/missing_value_policy_experiments.ipynb b/notebooks/missing_value_policy_experiments.ipynb new file mode 100644 index 000000000..e403252a0 --- /dev/null +++ b/notebooks/missing_value_policy_experiments.ipynb @@ -0,0 +1,1036 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "23e2f840", + "metadata": {}, + "source": [ + "# HoeffdingTree Missing-Value Policy Experiments\n", + "\n", + "This notebook compares `HoeffdingTree(missing_value_policy=...)` on several CapyMOA classification datasets.\n", + "\n", + "The experiment is prequential: predict first, update a `ClassificationEvaluator`, then train on the same instance. Missing values are injected only into the prediction copy, while training still receives the original complete instance. This isolates how each prediction-time missing-value policy behaves:\n", + "\n", + "- `default`: use MOA's default routing behavior\n", + "- `random`: follow one randomly chosen child\n", + "- `all`: follow all reachable children and combine their votes\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "dff08190", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eca265cc", + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from capymoa.classifier import HoeffdingTree\n", + "from capymoa.datasets import Covtype, Electricity, Hyper100k, RBFm_100k, RTG_2abrupt\n", + "from capymoa.evaluation import ClassificationEvaluator\n", + "from capymoa.instance import Instance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6f55c7f", + "metadata": {}, + "outputs": [], + "source": [ + "DATASETS = {\n", + " \"Electricity\": Electricity,\n", + " \"Covtype\": Covtype,\n", + " \"Hyper100k\": Hyper100k,\n", + " \"RBFm_100k\": RBFm_100k,\n", + " \"RTG_2abrupt\": RTG_2abrupt,\n", + "}\n", + "\n", + "POLICIES = [\"default\", \"random\", \"all\"]\n", + "MISSING_RATES = [0.0, 0.3, 0.5, 0.7, 0.9]\n", + "SEED = 49" + ] + }, + { + "cell_type": "markdown", + "id": "9d3c558a", + "metadata": {}, + "source": [ + "## Helper Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d811c2de", + "metadata": {}, + "outputs": [], + "source": [ + "def inject_missing_values(schema, instance, rng, missing_rate):\n", + " \"\"\"Return an unlabeled prediction instance with randomly missing features.\"\"\"\n", + " x = np.asarray(instance.x, dtype=float).copy()\n", + " mask = rng.random(x.shape[0]) < missing_rate\n", + "\n", + " if missing_rate > 0 and not mask.any():\n", + " mask[rng.integers(x.shape[0])] = True\n", + "\n", + " x[mask] = np.nan\n", + " prediction_instance = Instance.from_array(schema, x)\n", + " java_data = prediction_instance.java_instance.getData()\n", + "\n", + " for index in np.flatnonzero(mask):\n", + " java_data.setMissing(int(index))\n", + "\n", + " return prediction_instance, int(mask.sum())\n", + "\n", + "\n", + "def evaluate_dataset(dataset_name, dataset_cls, policy, missing_rate, seed=SEED):\n", + " stream = dataset_cls()\n", + " schema = stream.get_schema()\n", + " learner = HoeffdingTree(\n", + " schema=schema,\n", + " random_seed=seed,\n", + " missing_value_policy=policy,\n", + " )\n", + " evaluator = ClassificationEvaluator(schema=schema)\n", + " rng = np.random.default_rng(seed)\n", + "\n", + " instances = 0\n", + " abstained = 0\n", + " missing_values = 0\n", + " start = perf_counter()\n", + "\n", + " for instance in stream:\n", + "\n", + " prediction_instance, n_missing = inject_missing_values(\n", + " schema=schema,\n", + " instance=instance,\n", + " rng=rng,\n", + " missing_rate=missing_rate,\n", + " )\n", + " missing_values += n_missing\n", + "\n", + " prediction = learner.predict(prediction_instance)\n", + " abstained += int(prediction is None)\n", + " evaluator.update(instance.y_index, prediction)\n", + " learner.train(instance)\n", + " instances += 1\n", + "\n", + " elapsed = perf_counter() - start\n", + " return {\n", + " \"dataset\": dataset_name,\n", + " \"policy\": policy,\n", + " \"missing_rate\": missing_rate,\n", + " \"instances\": instances,\n", + " \"accuracy\": evaluator.accuracy(),\n", + " \"abstained\": abstained,\n", + " \"missing_values\": missing_values,\n", + " \"seconds\": elapsed,\n", + " \"instances_per_second\": instances / elapsed if elapsed else np.nan,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "6bd1f7b1", + "metadata": {}, + "source": [ + "## Run The Sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "27d60fd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Electricity missing_rate=0.0 policy=default\n", + "Electricity missing_rate=0.0 policy=random\n", + "Electricity missing_rate=0.0 policy=all\n", + "Electricity missing_rate=0.3 policy=default\n", + "Electricity missing_rate=0.3 policy=random\n", + "Electricity missing_rate=0.3 policy=all\n", + "Electricity missing_rate=0.5 policy=default\n", + "Electricity missing_rate=0.5 policy=random\n", + "Electricity missing_rate=0.5 policy=all\n", + "Electricity missing_rate=0.7 policy=default\n", + "Electricity missing_rate=0.7 policy=random\n", + "Electricity missing_rate=0.7 policy=all\n", + "Electricity missing_rate=0.9 policy=default\n", + "Electricity missing_rate=0.9 policy=random\n", + "Electricity missing_rate=0.9 policy=all\n", + "Covtype missing_rate=0.0 policy=default\n", + "Covtype missing_rate=0.0 policy=random\n", + "Covtype missing_rate=0.0 policy=all\n", + "Covtype missing_rate=0.3 policy=default\n", + "Covtype missing_rate=0.3 policy=random\n", + "Covtype missing_rate=0.3 policy=all\n", + "Covtype missing_rate=0.5 policy=default\n", + "Covtype missing_rate=0.5 policy=random\n", + "Covtype missing_rate=0.5 policy=all\n", + "Covtype missing_rate=0.7 policy=default\n", + "Covtype missing_rate=0.7 policy=random\n", + "Covtype missing_rate=0.7 policy=all\n", + "Covtype missing_rate=0.9 policy=default\n", + "Covtype missing_rate=0.9 policy=random\n", + "Covtype missing_rate=0.9 policy=all\n", + "Hyper100k missing_rate=0.0 policy=default\n", + "Hyper100k missing_rate=0.0 policy=random\n", + "Hyper100k missing_rate=0.0 policy=all\n", + "Hyper100k missing_rate=0.3 policy=default\n", + "Hyper100k missing_rate=0.3 policy=random\n", + "Hyper100k missing_rate=0.3 policy=all\n", + "Hyper100k missing_rate=0.5 policy=default\n", + "Hyper100k missing_rate=0.5 policy=random\n", + "Hyper100k missing_rate=0.5 policy=all\n", + "Hyper100k missing_rate=0.7 policy=default\n", + "Hyper100k missing_rate=0.7 policy=random\n", + "Hyper100k missing_rate=0.7 policy=all\n", + "Hyper100k missing_rate=0.9 policy=default\n", + "Hyper100k missing_rate=0.9 policy=random\n", + "Hyper100k missing_rate=0.9 policy=all\n", + "RBFm_100k missing_rate=0.0 policy=default\n", + "RBFm_100k missing_rate=0.0 policy=random\n", + "RBFm_100k missing_rate=0.0 policy=all\n", + "RBFm_100k missing_rate=0.3 policy=default\n", + "RBFm_100k missing_rate=0.3 policy=random\n", + "RBFm_100k missing_rate=0.3 policy=all\n", + "RBFm_100k missing_rate=0.5 policy=default\n", + "RBFm_100k missing_rate=0.5 policy=random\n", + "RBFm_100k missing_rate=0.5 policy=all\n", + "RBFm_100k missing_rate=0.7 policy=default\n", + "RBFm_100k missing_rate=0.7 policy=random\n", + "RBFm_100k missing_rate=0.7 policy=all\n", + "RBFm_100k missing_rate=0.9 policy=default\n", + "RBFm_100k missing_rate=0.9 policy=random\n", + "RBFm_100k missing_rate=0.9 policy=all\n", + "RTG_2abrupt missing_rate=0.0 policy=default\n", + "RTG_2abrupt missing_rate=0.0 policy=random\n", + "RTG_2abrupt missing_rate=0.0 policy=all\n", + "RTG_2abrupt missing_rate=0.3 policy=default\n", + "RTG_2abrupt missing_rate=0.3 policy=random\n", + "RTG_2abrupt missing_rate=0.3 policy=all\n", + "RTG_2abrupt missing_rate=0.5 policy=default\n", + "RTG_2abrupt missing_rate=0.5 policy=random\n", + "RTG_2abrupt missing_rate=0.5 policy=all\n", + "RTG_2abrupt missing_rate=0.7 policy=default\n", + "RTG_2abrupt missing_rate=0.7 policy=random\n", + "RTG_2abrupt missing_rate=0.7 policy=all\n", + "RTG_2abrupt missing_rate=0.9 policy=default\n", + "RTG_2abrupt missing_rate=0.9 policy=random\n", + "RTG_2abrupt missing_rate=0.9 policy=all\n" + ] + } + ], + "source": [ + "rows = []\n", + "\n", + "for dataset_name, dataset_cls in DATASETS.items():\n", + " for missing_rate in MISSING_RATES:\n", + " for policy in POLICIES:\n", + " print(f\"{dataset_name:15s} missing_rate={missing_rate:.1f} policy={policy}\")\n", + " rows.append(\n", + " evaluate_dataset(\n", + " dataset_name=dataset_name,\n", + " dataset_cls=dataset_cls,\n", + " policy=policy,\n", + " missing_rate=missing_rate,\n", + " )\n", + " )\n", + "\n", + "results = pd.DataFrame(rows)" + ] + }, + { + "cell_type": "markdown", + "id": "7d205608", + "metadata": {}, + "source": [ + "## Accuracy Comparison Table\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ac49b217", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
policyalldefaultrandom
datasetmissing_rate
Covtype0.052.0352.0352.03
0.353.5348.5047.83
0.552.3445.1543.31
0.750.6141.7038.49
0.949.2638.2434.22
Electricity0.081.2281.2281.22
0.373.8872.2569.61
0.568.3367.6562.25
0.761.7763.3855.19
0.955.2759.3548.48
Hyper100k0.087.8887.8887.88
0.375.6264.6073.38
0.569.2058.6866.69
0.762.9154.5260.01
0.955.3051.4353.24
RBFm_100k0.057.8057.8057.80
0.350.2736.5243.19
0.543.5032.8036.39
0.736.0230.9530.79
0.929.7730.3626.70
RTG_2abrupt0.056.6956.6956.69
0.351.6250.8249.62
0.548.2749.8646.51
0.745.2749.5044.15
0.943.2849.3142.29
\n", + "
" + ], + "text/plain": [ + "policy all default random\n", + "dataset missing_rate \n", + "Covtype 0.0 52.03 52.03 52.03\n", + " 0.3 53.53 48.50 47.83\n", + " 0.5 52.34 45.15 43.31\n", + " 0.7 50.61 41.70 38.49\n", + " 0.9 49.26 38.24 34.22\n", + "Electricity 0.0 81.22 81.22 81.22\n", + " 0.3 73.88 72.25 69.61\n", + " 0.5 68.33 67.65 62.25\n", + " 0.7 61.77 63.38 55.19\n", + " 0.9 55.27 59.35 48.48\n", + "Hyper100k 0.0 87.88 87.88 87.88\n", + " 0.3 75.62 64.60 73.38\n", + " 0.5 69.20 58.68 66.69\n", + " 0.7 62.91 54.52 60.01\n", + " 0.9 55.30 51.43 53.24\n", + "RBFm_100k 0.0 57.80 57.80 57.80\n", + " 0.3 50.27 36.52 43.19\n", + " 0.5 43.50 32.80 36.39\n", + " 0.7 36.02 30.95 30.79\n", + " 0.9 29.77 30.36 26.70\n", + "RTG_2abrupt 0.0 56.69 56.69 56.69\n", + " 0.3 51.62 50.82 49.62\n", + " 0.5 48.27 49.86 46.51\n", + " 0.7 45.27 49.50 44.15\n", + " 0.9 43.28 49.31 42.29" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accuracy_table = results.pivot_table(\n", + " index=[\"dataset\", \"missing_rate\"],\n", + " columns=\"policy\",\n", + " values=\"accuracy\",\n", + ")\n", + "accuracy_table.round(2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "586c756c", + "metadata": {}, + "source": [ + "## Runtime Comparison Table" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08da1ac5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
policyalldefaultrandom
datasetmissing_rate
Covtype0.059.38157.17461.293
0.3208.90165.41396.823
0.5364.07666.50394.612
0.7661.82364.62694.650
0.91111.17465.96795.013
Electricity0.02.1392.4151.933
0.36.3662.1163.642
0.58.9242.1453.602
0.712.2492.2403.935
0.916.4182.1693.805
Hyper100k0.04.8654.7664.822
0.312.2854.9428.589
0.517.8445.0319.010
0.726.8325.2009.338
0.941.1065.2899.819
RBFm_100k0.04.9494.8984.892
0.39.7305.0707.828
0.512.4595.0828.109
0.716.3655.2918.429
0.922.1275.3398.684
RTG_2abrupt0.08.1928.0138.252
0.316.9218.53812.140
0.522.4888.93312.794
0.729.4009.19813.182
0.938.4779.39613.620
\n", + "
" + ], + "text/plain": [ + "policy all default random\n", + "dataset missing_rate \n", + "Covtype 0.0 59.381 57.174 61.293\n", + " 0.3 208.901 65.413 96.823\n", + " 0.5 364.076 66.503 94.612\n", + " 0.7 661.823 64.626 94.650\n", + " 0.9 1111.174 65.967 95.013\n", + "Electricity 0.0 2.139 2.415 1.933\n", + " 0.3 6.366 2.116 3.642\n", + " 0.5 8.924 2.145 3.602\n", + " 0.7 12.249 2.240 3.935\n", + " 0.9 16.418 2.169 3.805\n", + "Hyper100k 0.0 4.865 4.766 4.822\n", + " 0.3 12.285 4.942 8.589\n", + " 0.5 17.844 5.031 9.010\n", + " 0.7 26.832 5.200 9.338\n", + " 0.9 41.106 5.289 9.819\n", + "RBFm_100k 0.0 4.949 4.898 4.892\n", + " 0.3 9.730 5.070 7.828\n", + " 0.5 12.459 5.082 8.109\n", + " 0.7 16.365 5.291 8.429\n", + " 0.9 22.127 5.339 8.684\n", + "RTG_2abrupt 0.0 8.192 8.013 8.252\n", + " 0.3 16.921 8.538 12.140\n", + " 0.5 22.488 8.933 12.794\n", + " 0.7 29.400 9.198 13.182\n", + " 0.9 38.477 9.396 13.620" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "runtime_table = results.pivot_table(\n", + " index=[\"dataset\", \"missing_rate\"],\n", + " columns=\"policy\",\n", + " values=\"seconds\",\n", + ")\n", + "runtime_table.round(3)\n" + ] + }, + { + "cell_type": "markdown", + "id": "14955ef5", + "metadata": {}, + "source": [ + "## Plot Helpers" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b5fca49", + "metadata": {}, + "outputs": [], + "source": [ + "POLICY_COLORS = {\n", + " \"default\": \"#4C78A8\",\n", + " \"random\": \"#F58518\",\n", + " \"all\": \"#54A24B\",\n", + "}\n", + "\n", + "\n", + "def plot_metric_by_dataset(results, metric, ylabel, title):\n", + " datasets = list(results[\"dataset\"].drop_duplicates())\n", + " fig, axes = plt.subplots(\n", + " 1,\n", + " len(datasets),\n", + " figsize=(4.2 * len(datasets), 3.6),\n", + " sharey=metric == \"accuracy\",\n", + " constrained_layout=True,\n", + " )\n", + "\n", + " if len(datasets) == 1:\n", + " axes = [axes]\n", + "\n", + " for ax, dataset in zip(axes, datasets):\n", + " dataset_results = results[results[\"dataset\"] == dataset]\n", + " for policy in POLICIES:\n", + " policy_results = dataset_results[dataset_results[\"policy\"] == policy].sort_values(\"missing_rate\")\n", + " ax.plot(\n", + " policy_results[\"missing_rate\"],\n", + " policy_results[metric],\n", + " marker=\"o\",\n", + " linewidth=2,\n", + " label=policy,\n", + " color=POLICY_COLORS[policy],\n", + " )\n", + " ax.set_title(dataset)\n", + " ax.set_xlabel(\"Missing rate\")\n", + " ax.grid(True, axis=\"y\", alpha=0.25)\n", + "\n", + " axes[0].set_ylabel(ylabel)\n", + " axes[-1].legend(title=\"Policy\", loc=\"best\")\n", + " fig.suptitle(title, fontsize=14)\n", + " return fig, axes\n" + ] + }, + { + "cell_type": "markdown", + "id": "50f23afb", + "metadata": {}, + "source": [ + "## Accuracy Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7c74ecf9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_metric_by_dataset(\n", + " results=results,\n", + " metric=\"accuracy\",\n", + " ylabel=\"Accuracy (%)\",\n", + " title=\"HoeffdingTree Missing-Value Policy Accuracy\",\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "77fb2105", + "metadata": {}, + "source": [ + "## Running Time Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ea2326b5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_metric_by_dataset(\n", + " results=results,\n", + " metric=\"seconds\",\n", + " ylabel=\"Running time (seconds)\",\n", + " title=\"HoeffdingTree Missing-Value Policy Running Time\",\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "e71b8bde", + "metadata": {}, + "source": [ + "## Best Overall Policy Per Dataset\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "57bfe230", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datasetpolicymean_accuracymean_secondstotal_seconds
0Covtypeall51.55481.0712405.354
4Electricitydefault68.772.21711.084
6Hyper100kall70.1820.586102.932
9RBFm_100kall43.4713.12665.630
13RTG_2abruptdefault51.248.81644.078
\n", + "
" + ], + "text/plain": [ + " dataset policy mean_accuracy mean_seconds total_seconds\n", + "0 Covtype all 51.55 481.071 2405.354\n", + "4 Electricity default 68.77 2.217 11.084\n", + "6 Hyper100k all 70.18 20.586 102.932\n", + "9 RBFm_100k all 43.47 13.126 65.630\n", + "13 RTG_2abrupt default 51.24 8.816 44.078" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "policy_summary = (\n", + " results.groupby([\"dataset\", \"policy\"], as_index=False)\n", + " .agg(\n", + " mean_accuracy=(\"accuracy\", \"mean\"),\n", + " mean_seconds=(\"seconds\", \"mean\"),\n", + " total_seconds=(\"seconds\", \"sum\"),\n", + " )\n", + ")\n", + "\n", + "best_overall_policy = policy_summary.loc[\n", + " policy_summary.groupby(\"dataset\")[\"mean_accuracy\"].idxmax()\n", + "].sort_values(\"dataset\")\n", + "\n", + "best_overall_policy.round({\n", + " \"mean_accuracy\": 2,\n", + " \"mean_seconds\": 3,\n", + " \"total_seconds\": 3,\n", + "})\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From be8adcf0a4507c3de5a2e7f93dccb676c9a088ce Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Fri, 24 Apr 2026 01:16:13 +0700 Subject: [PATCH 6/7] docs: rename HoeffdingTree tutorial notebooks --- ...fding_tree.ipynb => hoeffding_tree_missing_value_policy.ipynb} | 0 ...pynb => hoeffding_tree_missing_value_policy_experiments.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename notebooks/{missing_value_policy_hoeffding_tree.ipynb => hoeffding_tree_missing_value_policy.ipynb} (100%) rename notebooks/{missing_value_policy_experiments.ipynb => hoeffding_tree_missing_value_policy_experiments.ipynb} (100%) diff --git a/notebooks/missing_value_policy_hoeffding_tree.ipynb b/notebooks/hoeffding_tree_missing_value_policy.ipynb similarity index 100% rename from notebooks/missing_value_policy_hoeffding_tree.ipynb rename to notebooks/hoeffding_tree_missing_value_policy.ipynb diff --git a/notebooks/missing_value_policy_experiments.ipynb b/notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb similarity index 100% rename from notebooks/missing_value_policy_experiments.ipynb rename to notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb From 41f55ae9a2dc506f0b437c378df1c508ad2dc244 Mon Sep 17 00:00:00 2001 From: Sekar Minati Date: Thu, 30 Apr 2026 13:06:17 +0700 Subject: [PATCH 7/7] docs: update HoeffdingTree tutorial and improve notebook formatting --- docs/tutorials.rst | 3 +- .../hoeffding_tree_missing_value_policy.ipynb | 9 ++++- ...ree_missing_value_policy_experiments.ipynb | 38 +++++++++---------- src/capymoa/classifier/__init__.py | 3 +- src/capymoa/classifier/_hoeffding_tree.py | 4 +- src/capymoa/visualization/tree.py | 4 +- 6 files changed, 32 insertions(+), 29 deletions(-) diff --git a/docs/tutorials.rst b/docs/tutorials.rst index fa7318cc0..008ed5353 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -32,7 +32,8 @@ These tutorials will show you how to get started with the CapyMOA library. notebooks/save_and_load_model.ipynb notebooks/clustering.ipynb notebooks/feature_importance.ipynb - notebooks/missing_value_policy_hoeffding_tree.ipynb + notebooks/hoeffding_tree_missing_value_policy.ipynb + notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb Talks ===== diff --git a/notebooks/hoeffding_tree_missing_value_policy.ipynb b/notebooks/hoeffding_tree_missing_value_policy.ipynb index 694da693d..1eb4b57f8 100644 --- a/notebooks/hoeffding_tree_missing_value_policy.ipynb +++ b/notebooks/hoeffding_tree_missing_value_policy.ipynb @@ -51,6 +51,7 @@ "\n", "try:\n", " from graphviz import Source\n", + "\n", " GRAPHVIZ_AVAILABLE = True\n", "except Exception:\n", " GRAPHVIZ_AVAILABLE = False\n", @@ -76,7 +77,9 @@ " if GRAPHVIZ_AVAILABLE:\n", " display(Source(dot))\n", " else:\n", - " display(Markdown(\"Graphviz is not available, so the DOT source is shown below.\"))\n", + " display(\n", + " Markdown(\"Graphviz is not available, so the DOT source is shown below.\")\n", + " )\n", " display(Markdown(\"```dot\\n\" + dot + \"\\n```\"))\n", "\n", "\n", @@ -188,7 +191,9 @@ "\n", "print(\"Missing feature index:\", missing_index)\n", "print(\"x:\", example.x)\n", - "print(\"Java missing flag:\", example.java_instance.getData().isMissing(int(missing_index)))" + "print(\n", + " \"Java missing flag:\", example.java_instance.getData().isMissing(int(missing_index))\n", + ")" ] }, { diff --git a/notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb b/notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb index e403252a0..d5100e5c5 100644 --- a/notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb +++ b/notebooks/hoeffding_tree_missing_value_policy_experiments.ipynb @@ -114,7 +114,6 @@ " start = perf_counter()\n", "\n", " for instance in stream:\n", - "\n", " prediction_instance, n_missing = inject_missing_values(\n", " schema=schema,\n", " instance=instance,\n", @@ -507,7 +506,7 @@ " columns=\"policy\",\n", " values=\"accuracy\",\n", ")\n", - "accuracy_table.round(2)\n" + "accuracy_table.round(2)" ] }, { @@ -759,7 +758,7 @@ " columns=\"policy\",\n", " values=\"seconds\",\n", ")\n", - "runtime_table.round(3)\n" + "runtime_table.round(3)" ] }, { @@ -800,7 +799,9 @@ " for ax, dataset in zip(axes, datasets):\n", " dataset_results = results[results[\"dataset\"] == dataset]\n", " for policy in POLICIES:\n", - " policy_results = dataset_results[dataset_results[\"policy\"] == policy].sort_values(\"missing_rate\")\n", + " policy_results = dataset_results[\n", + " dataset_results[\"policy\"] == policy\n", + " ].sort_values(\"missing_rate\")\n", " ax.plot(\n", " policy_results[\"missing_rate\"],\n", " policy_results[metric],\n", @@ -816,7 +817,7 @@ " axes[0].set_ylabel(ylabel)\n", " axes[-1].legend(title=\"Policy\", loc=\"best\")\n", " fig.suptitle(title, fontsize=14)\n", - " return fig, axes\n" + " return fig, axes" ] }, { @@ -851,7 +852,7 @@ " ylabel=\"Accuracy (%)\",\n", " title=\"HoeffdingTree Missing-Value Policy Accuracy\",\n", ")\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -886,7 +887,7 @@ " ylabel=\"Running time (seconds)\",\n", " title=\"HoeffdingTree Missing-Value Policy Running Time\",\n", ")\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -991,24 +992,23 @@ } ], "source": [ - "policy_summary = (\n", - " results.groupby([\"dataset\", \"policy\"], as_index=False)\n", - " .agg(\n", - " mean_accuracy=(\"accuracy\", \"mean\"),\n", - " mean_seconds=(\"seconds\", \"mean\"),\n", - " total_seconds=(\"seconds\", \"sum\"),\n", - " )\n", + "policy_summary = results.groupby([\"dataset\", \"policy\"], as_index=False).agg(\n", + " mean_accuracy=(\"accuracy\", \"mean\"),\n", + " mean_seconds=(\"seconds\", \"mean\"),\n", + " total_seconds=(\"seconds\", \"sum\"),\n", ")\n", "\n", "best_overall_policy = policy_summary.loc[\n", " policy_summary.groupby(\"dataset\")[\"mean_accuracy\"].idxmax()\n", "].sort_values(\"dataset\")\n", "\n", - "best_overall_policy.round({\n", - " \"mean_accuracy\": 2,\n", - " \"mean_seconds\": 3,\n", - " \"total_seconds\": 3,\n", - "})\n" + "best_overall_policy.round(\n", + " {\n", + " \"mean_accuracy\": 2,\n", + " \"mean_seconds\": 3,\n", + " \"total_seconds\": 3,\n", + " }\n", + ")" ] } ], diff --git a/src/capymoa/classifier/__init__.py b/src/capymoa/classifier/__init__.py index dbdf0cea9..4966c8051 100644 --- a/src/capymoa/classifier/__init__.py +++ b/src/capymoa/classifier/__init__.py @@ -1,6 +1,6 @@ from ._adaptive_random_forest import AdaptiveRandomForestClassifier from ._efdt import EFDT -from ._hoeffding_tree import HoeffdingTree +from ._hoeffding_tree import HoeffdingTree, TreePredictionTrace from ._last import LAST from ._naive_bayes import NaiveBayes from ._online_bagging import OnlineBagging @@ -33,6 +33,7 @@ "Finetune", "HoeffdingAdaptiveTree", "HoeffdingTree", + "TreePredictionTrace", "KNN", "LAST", "LeveragingBagging", diff --git a/src/capymoa/classifier/_hoeffding_tree.py b/src/capymoa/classifier/_hoeffding_tree.py index 1887eab59..22f5aa01e 100644 --- a/src/capymoa/classifier/_hoeffding_tree.py +++ b/src/capymoa/classifier/_hoeffding_tree.py @@ -257,9 +257,7 @@ def _trace_prediction_path(self, java_instance, node) -> TreePredictionTrace: self._trace_prediction_path(java_instance, child) for _, child in children ] - edges = tuple( - (node, branch_idx, child) for branch_idx, child in children - ) + edges = tuple((node, branch_idx, child) for branch_idx, child in children) return TreePredictionTrace( votes=self._sum_votes([trace.votes for trace in child_traces]), vote_source_node=None, diff --git a/src/capymoa/visualization/tree.py b/src/capymoa/visualization/tree.py index e2c9bbc41..dd89813c2 100644 --- a/src/capymoa/visualization/tree.py +++ b/src/capymoa/visualization/tree.py @@ -259,9 +259,7 @@ def export_hoeffding_tree_to_dot( trace_proba = model._normalize_votes(trace.votes) instance_text = _format_instance_text(model, sample_instance) - prediction_text = _format_prediction_text( - model, sample_instance, proba=trace_proba - ) + prediction_text = _format_prediction_text(model, sample_instance, proba=trace_proba) graph_label = f"{title}\n{instance_text}\n{prediction_text}"