ebele-entropy-tree 0.1.0__tar.gz

ebele_entropy_tree-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ebelechukwu Umezude
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ebele_entropy_tree-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md LICENSE report.md PUBLISHING.md
+recursive-include examples *.py *.csv
+recursive-include tests *.py

ebele_entropy_tree-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: ebele-entropy-tree
+Version: 0.1.0
+Summary: An educational categorical ID3 decision tree built from scratch
+Author: Ebelechukwu Umezude
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Entropy decision tree from scratch
+
+Educational implementation of ID3 for categorical data. The learning algorithm
+uses only the Python standard library: no scikit-learn decision tree is used.
+Prepared with AI assistance; review the code and report before submission.
+
+## Install locally and run
+
+Open a terminal in this project folder (the folder containing pyproject.toml):
+
+```bash
+python3 -m pip install -e .
+python3 examples/tennis_demo.py
+python3 -m unittest discover -s tests -v
+```
+
+Open `tree.svg` in your browser for a graphical display. The SVG is generated
+from the learned tree, not hard-coded. `model.display()` also prints the rules.
+
+## Use the package
+
+```python
+from ebele_tree import DecisionTreeClassifier
+X = [{"Outlook": "Sunny"}, {"Outlook": "Rain"}, {"Outlook": "Overcast"}]
+y = ["No", "Yes", "Yes"]
+model = DecisionTreeClassifier(max_depth=2).fit(X, y)
+print(model.predict([{"Outlook": "Sunny"}]))
+model.display()
+model.export_svg("my_tree.svg")
+```
+
+In a notebook, a pandas DataFrame can be converted with
+`X.to_dict(orient="records")`; labels can be passed as `y.tolist()`.
+To display the exported SVG in a notebook:
+
+```python
+from IPython.display import SVG, display
+model.export_svg("tree.svg")
+display(SVG(filename="tree.svg"))
+```
+
+## How learning works
+
+1. Count the target labels and calculate H(S) = -sum(p * log2(p)).
+2. For each feature, group rows by category and calculate the weighted child entropy.
+3. Gain = parent entropy minus weighted child entropy.
+4. Choose the feature with the largest gain.
+5. Repeat separately within each branch, removing the selected feature.
+6. Stop at a pure node, no useful gain, no remaining feature, or a size limit.
+7. A stopped node predicts its majority class. Ties use first appearance order.
+
+`max_depth` controls depth (root depth is 0). `min_samples_split` controls how
+many examples are required before splitting. `min_gain` controls the minimum
+useful gain. A category unseen during fitting uses the current node's majority.
+
+## Tennis example
+
+The 14 rows reproduce the lecture's Play Tennis example. `Day` is excluded as
+an identifier. Categories are used directly; no numeric encoding is needed.
+
+| Feature | Root information gain |
+|---|---:|
+| Outlook | 0.246750 |
+| Temperature | 0.029223 |
+| Humidity | 0.151836 |
+| Wind | 0.048127 |
+
+The learned tree starts with Outlook; Sunny uses Humidity and Rain uses Wind.
+Overcast immediately predicts Yes. With max_depth=2, training accuracy is 1.0.
+That is a training demonstration, not evidence of perfect generalisation.
+
+## Scope and limitations
+
+Categorical, hashable, nonmissing inputs only. Numeric values are treated as
+discrete categories; continuous threshold splits are not implemented. This is
+an educational implementation, not an efficient model for the large irrigation
+dataset. Graphical boxes are sized for short labels such as the tennis example.
+
+See PUBLISHING.md for GitHub and PyPI instructions. The package name
+`ebele-entropy-tree` is provisional: availability has not been checked.

ebele_entropy_tree-0.1.0/PUBLISHING.md

@@ -0,0 +1,84 @@
+# Finish and publish
+
+## 1. Check locally
+
+Extract the zip, open a terminal inside decision-tree-homework, and run:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+python examples/tennis_demo.py
+python -m unittest discover -s tests -v
+```
+
+Open tree.svg in a browser. Keep .venv out of GitHub.
+
+## 2. GitHub
+
+Create a repository in your GitHub account, for example `decision-tree-from-scratch`.
+Use GitHub's Add file > Upload files to upload the CONTENTS of the extracted
+folder, preserving src/, examples/ and tests/. Do not upload just the zip.
+If using a terminal instead, follow GitHub's displayed commands for your new
+repository. Do not upload .venv/, build/, dist/, API tokens or account secrets.
+
+Replace the GitHub placeholder in report.md with your actual repository URL.
+Keep the large irrigation CSVs out of this homework repository.
+The separate Kaggle repository should contain the completed irrigation notebook,
+a README describing its dataset/metric/results and environment requirements.
+Use a data-source link instead of copying competition data without permission.
+
+## 3. Prepare PyPI
+
+PyPI (Python Package Index) is https://pypi.org, not the alternative interpreter PyPy.
+Create/verify your account and complete the security setup required by PyPI.
+Check whether the distribution name `ebele-entropy-tree` is available.
+If taken, edit only project.name in pyproject.toml to a unique name; the import
+name remains ebele_tree. Do this before building.
+
+## 4. Build and check
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+This should produce a wheel (.whl) and source archive (.tar.gz).
+If you change the package name/version, remove old files from dist/ before
+rebuilding, so you do not accidentally upload a previous build.
+
+## 5. Publish to the real PyPI for the bonus
+
+After you have reviewed the package and are ready to make it public:
+
+```bash
+python -m twine upload dist/*
+```
+
+Use a PyPI API token via the secure prompt (username __token__ if requested).
+Never place tokens in code, report.md, GitHub, screenshots or this chat.
+TestPyPI is a separate service and does not by itself satisfy a real PyPI release.
+
+When upload succeeds, open the package's actual PyPI page. In a fresh environment,
+install it using the exact distribution name you published:
+
+```bash
+python -m pip install ebele-entropy-tree==0.1.0
+python -c "from ebele_tree import entropy; print(entropy(['Yes', 'No']))"
+```
+
+If you chose a different name, replace ebele-entropy-tree in the install command.
+Expected output is 1.0. Add the actual PyPI URL and install command to report.md,
+update the bonus status to describe what actually succeeded, then update GitHub.
+Published versions cannot be overwritten: use a higher version for later fixes.
+
+## 6. Submit the assignment
+
+Check report.md has real links and no unfinished placeholders. Read it and edit
+the description to match your understanding and actual actions. Attach report.md
+to the Teams assignment and click Turn in before the displayed 23:59 deadline.
+
+Official packaging guide:
+https://packaging.python.org/en/latest/tutorials/packaging-projects/

ebele_entropy_tree-0.1.0/README.md

@@ -0,0 +1,80 @@
+# Entropy decision tree from scratch
+
+Educational implementation of ID3 for categorical data. The learning algorithm
+uses only the Python standard library: no scikit-learn decision tree is used.
+Prepared with AI assistance; review the code and report before submission.
+
+## Install locally and run
+
+Open a terminal in this project folder (the folder containing pyproject.toml):
+
+```bash
+python3 -m pip install -e .
+python3 examples/tennis_demo.py
+python3 -m unittest discover -s tests -v
+```
+
+Open `tree.svg` in your browser for a graphical display. The SVG is generated
+from the learned tree, not hard-coded. `model.display()` also prints the rules.
+
+## Use the package
+
+```python
+from ebele_tree import DecisionTreeClassifier
+X = [{"Outlook": "Sunny"}, {"Outlook": "Rain"}, {"Outlook": "Overcast"}]
+y = ["No", "Yes", "Yes"]
+model = DecisionTreeClassifier(max_depth=2).fit(X, y)
+print(model.predict([{"Outlook": "Sunny"}]))
+model.display()
+model.export_svg("my_tree.svg")
+```
+
+In a notebook, a pandas DataFrame can be converted with
+`X.to_dict(orient="records")`; labels can be passed as `y.tolist()`.
+To display the exported SVG in a notebook:
+
+```python
+from IPython.display import SVG, display
+model.export_svg("tree.svg")
+display(SVG(filename="tree.svg"))
+```
+
+## How learning works
+
+1. Count the target labels and calculate H(S) = -sum(p * log2(p)).
+2. For each feature, group rows by category and calculate the weighted child entropy.
+3. Gain = parent entropy minus weighted child entropy.
+4. Choose the feature with the largest gain.
+5. Repeat separately within each branch, removing the selected feature.
+6. Stop at a pure node, no useful gain, no remaining feature, or a size limit.
+7. A stopped node predicts its majority class. Ties use first appearance order.
+
+`max_depth` controls depth (root depth is 0). `min_samples_split` controls how
+many examples are required before splitting. `min_gain` controls the minimum
+useful gain. A category unseen during fitting uses the current node's majority.
+
+## Tennis example
+
+The 14 rows reproduce the lecture's Play Tennis example. `Day` is excluded as
+an identifier. Categories are used directly; no numeric encoding is needed.
+
+| Feature | Root information gain |
+|---|---:|
+| Outlook | 0.246750 |
+| Temperature | 0.029223 |
+| Humidity | 0.151836 |
+| Wind | 0.048127 |
+
+The learned tree starts with Outlook; Sunny uses Humidity and Rain uses Wind.
+Overcast immediately predicts Yes. With max_depth=2, training accuracy is 1.0.
+That is a training demonstration, not evidence of perfect generalisation.
+
+## Scope and limitations
+
+Categorical, hashable, nonmissing inputs only. Numeric values are treated as
+discrete categories; continuous threshold splits are not implemented. This is
+an educational implementation, not an efficient model for the large irrigation
+dataset. Graphical boxes are sized for short labels such as the tennis example.
+
+See PUBLISHING.md for GitHub and PyPI instructions. The package name
+`ebele-entropy-tree` is provisional: availability has not been checked.

ebele_entropy_tree-0.1.0/examples/tennis.csv

@@ -0,0 +1,15 @@
+Day,Outlook,Temperature,Humidity,Wind,Play_Tennis
+D1,Sunny,Hot,High,Weak,No
+D2,Sunny,Hot,High,Strong,No
+D3,Overcast,Hot,High,Weak,Yes
+D4,Rain,Mild,High,Weak,Yes
+D5,Rain,Cool,Normal,Weak,Yes
+D6,Rain,Cool,Normal,Strong,No
+D7,Overcast,Cool,Normal,Strong,Yes
+D8,Sunny,Mild,High,Weak,No
+D9,Sunny,Cool,Normal,Weak,Yes
+D10,Rain,Mild,Normal,Weak,Yes
+D11,Sunny,Mild,Normal,Strong,Yes
+D12,Overcast,Mild,High,Strong,Yes
+D13,Overcast,Hot,Normal,Weak,Yes
+D14,Rain,Mild,High,Strong,No

ebele_entropy_tree-0.1.0/examples/tennis_demo.py

@@ -0,0 +1,17 @@
+import csv
+from pathlib import Path
+from ebele_tree import DecisionTreeClassifier, entropy, information_gain
+
+with Path(__file__).with_name("tennis.csv").open() as f:
+    rows = list(csv.DictReader(f))
+y = [row["Play_Tennis"] for row in rows]
+X = [{k: v for k, v in row.items() if k not in ("Day", "Play_Tennis")} for row in rows]
+print("Dataset entropy:", round(entropy(y), 6))
+for feature in X[0]:
+    print(feature, "gain:", round(information_gain([r[feature] for r in X], y), 6))
+model = DecisionTreeClassifier(max_depth=2).fit(X, y)
+model.display()
+print("Training accuracy (not unseen-data accuracy):", model.score(X, y))
+print("New Sunny/High day:", model.predict([X[0]]))
+model.export_svg("tree.svg")
+print("Open tree.svg in your browser to see the tree.")

ebele_entropy_tree-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ebele-entropy-tree"
+version = "0.1.0"
+description = "An educational categorical ID3 decision tree built from scratch"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{name = "Ebelechukwu Umezude"}]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

ebele_entropy_tree-0.1.0/report.md

@@ -0,0 +1,60 @@
+# Decision Tree algorithm — report
+
+Name: Ebelechukwu Umezude
+
+GitHub repository: https://github.com/ebyumezude/decision-tree-from-scratch
+
+PyPI package: **NOT PUBLISHED YET — replace with the actual public PyPI URL after publishing**
+
+## Objective
+
+Implement a decision tree classifier from scratch using entropy and information
+gain, with a hyperparameter controlling tree size and a way to display the tree.
+
+## Implementation
+
+The package implements categorical ID3 using Python's standard library.
+Entropy measures class impurity. For each candidate feature, information gain
+subtracts the weighted entropy of its branches from the current node's entropy.
+The feature with maximum gain becomes the split. The procedure repeats within
+each branch until a stopping rule applies.
+
+`max_depth` limits depth; the root is at depth zero. `min_samples_split` and
+`min_gain` provide additional stopping rules. Leaves predict the majority class.
+Unseen categories fall back to the majority class at the current node.
+The row identifier Day is excluded. Categories are used directly without encoding.
+
+## Example and results
+
+The lecture's 14-row tennis dataset has nine Yes labels and five No labels.
+Its entropy is approximately 0.940286. Root gains are Outlook 0.246750,
+Humidity 0.151836, Wind 0.048127 and Temperature 0.029223.
+The learned root is Outlook. Sunny splits by Humidity; Rain splits by Wind;
+Overcast predicts Yes directly. At max_depth=2 the tree fits all 14 training
+examples. At max_depth=0 it predicts the overall majority class, Yes.
+Training accuracy is not an estimate of performance on unseen data.
+
+## Display bonus
+
+`display()` prints the learned rules. `export_svg()` generates a graphical
+SVG tree that can be opened in a browser or displayed in a notebook.
+
+## Packaging bonus status
+
+The project includes pyproject.toml, package source, README, a license and tests.
+It is prepared for publishing, but being packaged locally or uploaded to GitHub
+is not the same as being published on PyPI. Update this section after the
+public release and include the real package URL and install command.
+
+## Verification and limitations
+
+Tests cover known entropy/gain values, the learned tennis structure, depth
+limits, unseen categories, stopping rules, invalid input, and SVG output.
+The implementation supports categorical data, not continuous threshold splits.
+Missing values must be cleaned first. The dataset is small and no independent
+test accuracy is claimed.
+
+## Assistance
+
+Code and explanatory material were prepared with ChatGPT assistance. I should
+review, run and understand the implementation before submitting this report.

ebele_entropy_tree-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ebele_entropy_tree-0.1.0/src/ebele_entropy_tree.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: ebele-entropy-tree
+Version: 0.1.0
+Summary: An educational categorical ID3 decision tree built from scratch
+Author: Ebelechukwu Umezude
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Entropy decision tree from scratch
+
+Educational implementation of ID3 for categorical data. The learning algorithm
+uses only the Python standard library: no scikit-learn decision tree is used.
+Prepared with AI assistance; review the code and report before submission.
+
+## Install locally and run
+
+Open a terminal in this project folder (the folder containing pyproject.toml):
+
+```bash
+python3 -m pip install -e .
+python3 examples/tennis_demo.py
+python3 -m unittest discover -s tests -v
+```
+
+Open `tree.svg` in your browser for a graphical display. The SVG is generated
+from the learned tree, not hard-coded. `model.display()` also prints the rules.
+
+## Use the package
+
+```python
+from ebele_tree import DecisionTreeClassifier
+X = [{"Outlook": "Sunny"}, {"Outlook": "Rain"}, {"Outlook": "Overcast"}]
+y = ["No", "Yes", "Yes"]
+model = DecisionTreeClassifier(max_depth=2).fit(X, y)
+print(model.predict([{"Outlook": "Sunny"}]))
+model.display()
+model.export_svg("my_tree.svg")
+```
+
+In a notebook, a pandas DataFrame can be converted with
+`X.to_dict(orient="records")`; labels can be passed as `y.tolist()`.
+To display the exported SVG in a notebook:
+
+```python
+from IPython.display import SVG, display
+model.export_svg("tree.svg")
+display(SVG(filename="tree.svg"))
+```
+
+## How learning works
+
+1. Count the target labels and calculate H(S) = -sum(p * log2(p)).
+2. For each feature, group rows by category and calculate the weighted child entropy.
+3. Gain = parent entropy minus weighted child entropy.
+4. Choose the feature with the largest gain.
+5. Repeat separately within each branch, removing the selected feature.
+6. Stop at a pure node, no useful gain, no remaining feature, or a size limit.
+7. A stopped node predicts its majority class. Ties use first appearance order.
+
+`max_depth` controls depth (root depth is 0). `min_samples_split` controls how
+many examples are required before splitting. `min_gain` controls the minimum
+useful gain. A category unseen during fitting uses the current node's majority.
+
+## Tennis example
+
+The 14 rows reproduce the lecture's Play Tennis example. `Day` is excluded as
+an identifier. Categories are used directly; no numeric encoding is needed.
+
+| Feature | Root information gain |
+|---|---:|
+| Outlook | 0.246750 |
+| Temperature | 0.029223 |
+| Humidity | 0.151836 |
+| Wind | 0.048127 |
+
+The learned tree starts with Outlook; Sunny uses Humidity and Rain uses Wind.
+Overcast immediately predicts Yes. With max_depth=2, training accuracy is 1.0.
+That is a training demonstration, not evidence of perfect generalisation.
+
+## Scope and limitations
+
+Categorical, hashable, nonmissing inputs only. Numeric values are treated as
+discrete categories; continuous threshold splits are not implemented. This is
+an educational implementation, not an efficient model for the large irrigation
+dataset. Graphical boxes are sized for short labels such as the tennis example.
+
+See PUBLISHING.md for GitHub and PyPI instructions. The package name
+`ebele-entropy-tree` is provisional: availability has not been checked.

ebele_entropy_tree-0.1.0/src/ebele_entropy_tree.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+PUBLISHING.md
+README.md
+pyproject.toml
+report.md
+examples/tennis.csv
+examples/tennis_demo.py
+src/ebele_entropy_tree.egg-info/PKG-INFO
+src/ebele_entropy_tree.egg-info/SOURCES.txt
+src/ebele_entropy_tree.egg-info/dependency_links.txt
+src/ebele_entropy_tree.egg-info/top_level.txt
+src/ebele_tree/__init__.py
+src/ebele_tree/tree.py
+tests/test_tree.py

ebele_entropy_tree-0.1.0/src/ebele_entropy_tree.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ebele_entropy_tree-0.1.0/src/ebele_entropy_tree.egg-info/top_level.txt

@@ -0,0 +1 @@
+ebele_tree

ebele_entropy_tree-0.1.0/src/ebele_tree/__init__.py

@@ -0,0 +1,3 @@
+from .tree import DecisionTreeClassifier, entropy, information_gain
+
+__all__ = ["DecisionTreeClassifier", "entropy", "information_gain"]

ebele_entropy_tree-0.1.0/src/ebele_tree/tree.py

@@ -0,0 +1,158 @@
+"""Categorical ID3 tree. Uses only Python's standard library."""
+from collections import Counter
+from html import escape
+from math import log2
+from pathlib import Path
+
+
+def entropy(labels):
+    """Shannon entropy in bits; an empty or pure group has entropy zero."""
+    labels = list(labels)
+    counts = Counter(labels)
+    return -sum((n / len(labels)) * log2(n / len(labels))
+                for n in counts.values()) if labels else 0.0
+
+
+def information_gain(values, labels):
+    """Parent entropy minus weighted child entropies."""
+    values, labels = list(values), list(labels)
+    if len(values) != len(labels) or not labels:
+        raise ValueError("Provide equally sized, nonempty values and labels.")
+    groups = {}
+    for value, label in zip(values, labels):
+        groups.setdefault(value, []).append(label)
+    return entropy(labels) - sum(len(group) / len(labels) * entropy(group)
+                                 for group in groups.values())
+
+
+class DecisionTreeClassifier:
+    """ID3 for categorical features, supplied as a list of dictionaries.
+
+    max_depth=0 gives a majority-class leaf; None allows unrestricted depth.
+    min_samples_split and min_gain provide additional stopping controls.
+    Unseen categories fall back to the current node's majority class.
+    Numeric values, if supplied, are discrete categories, NOT thresholds.
+    Missing values are not supported: clean/impute them before fitting.
+    """
+    def __init__(self, max_depth=None, min_samples_split=2, min_gain=1e-12):
+        if max_depth is not None and (type(max_depth) is not int or max_depth < 0):
+            raise ValueError("max_depth must be None or a nonnegative integer.")
+        if type(min_samples_split) is not int or min_samples_split < 2:
+            raise ValueError("min_samples_split must be an integer >= 2.")
+        if not isinstance(min_gain, (int, float)) or not 0 <= min_gain < float('inf'):
+            raise ValueError("min_gain must be a finite nonnegative number.")
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_gain = min_gain
+
+    def fit(self, X, y):
+        X, y = list(X), list(y)
+        if not X or len(X) != len(y):
+            raise ValueError("X and y must be nonempty and have equal lengths.")
+        if not all(isinstance(row, dict) for row in X):
+            raise ValueError("X must contain dictionaries.")
+        self.features_ = list(X[0])
+        if any(set(row) != set(self.features_) for row in X):
+            raise ValueError("All rows must have the same feature names.")
+        for value in [v for row in X for v in row.values()] + y:
+            if value is None or value != value:
+                raise ValueError("Missing values must be cleaned first.")
+            hash(value)
+        self.tree_ = self._build(X, y, self.features_, 0)
+        return self
+
+    def _build(self, X, y, features, depth):
+        # Counter preserves appearance order, making majority ties deterministic.
+        majority = Counter(y).most_common(1)[0][0]
+        node = {"prediction": majority, "samples": len(y), "entropy": entropy(y)}
+        if (len(set(y)) == 1 or not features or len(y) < self.min_samples_split
+                or (self.max_depth is not None and depth >= self.max_depth)):
+            return node
+        gains = {f: information_gain([row[f] for row in X], y) for f in features}
+        best = max(gains, key=gains.get)
+        if gains[best] <= self.min_gain:
+            return node
+        node.update(feature=best, gain=gains[best], children={})
+        remaining = [f for f in features if f != best]
+        for value in dict.fromkeys(row[best] for row in X):
+            indices = [i for i, row in enumerate(X) if row[best] == value]
+            node["children"][value] = self._build(
+                [X[i] for i in indices], [y[i] for i in indices], remaining, depth + 1)
+        return node
+
+    def _check_fitted(self):
+        if not hasattr(self, "tree_"):
+            raise ValueError("Call fit before predicting or displaying the tree.")
+
+    def predict(self, X):
+        self._check_fitted()
+        predictions = []
+        for row in X:
+            node = self.tree_
+            while "feature" in node:
+                feature = node["feature"]
+                if feature not in row:
+                    raise ValueError("Missing prediction feature: " + feature)
+                if row[feature] not in node["children"]:
+                    break
+                node = node["children"][row[feature]]
+            predictions.append(node["prediction"])
+        return predictions
+
+    def score(self, X, y):
+        y = list(y)
+        predictions = self.predict(X)
+        if not y or len(y) != len(predictions):
+            raise ValueError("Provide equally sized, nonempty X and y.")
+        return sum(a == b for a, b in zip(predictions, y)) / len(y)
+
+    def display(self):
+        """Print the learned rules with indentation showing each branch."""
+        self._check_fitted()
+        lines = []
+        def visit(node, indent=""):
+            if "feature" not in node:
+                lines.append(f"{indent}Predict {node['prediction']} (n={node['samples']})")
+            else:
+                lines.append(f"{indent}{node['feature']} (gain={node['gain']:.3f})")
+                for value, child in node["children"].items():
+                    lines.append(f"{indent}  If {node['feature']} = {value}:")
+                    visit(child, indent + "    ")
+        visit(self.tree_)
+        print("\n".join(lines))
+
+    def export_svg(self, filename="tree.svg"):
+        """Save a graphical tree, viewable directly in a web browser."""
+        self._check_fitted()
+        nodes, edges = [], []
+        leaf_count = 0
+        def layout(node, depth):
+            nonlocal leaf_count
+            children = []
+            for value, child in node.get("children", {}).items():
+                children.append((value, layout(child, depth + 1)))
+            if children:
+                x = sum(child[0] for _, child in children) / len(children)
+            else:
+                x = 140 + leaf_count * 240
+                leaf_count += 1
+            y = 60 + depth * 150
+            for value, child in children:
+                edges.append((x, y, child[0], child[1], str(value)))
+            label = str(node.get("feature", "Predict: " + str(node["prediction"])))
+            nodes.append((x, y, label, node['samples']))
+            return x, y
+        layout(self.tree_, 0)
+        width, height = max(280, leaf_count * 240 + 40), max(n[1] for n in nodes) + 60
+        svg = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">',
+               '<rect width="100%" height="100%" fill="white"/>']
+        for x1, y1, x2, y2, label in edges:
+            svg.append(f'<line x1="{x1}" y1="{y1+27}" x2="{x2}" y2="{y2-27}" stroke="#53677d"/>')
+            svg.append(f'<text x="{(x1+x2)/2}" y="{(y1+y2)/2}" text-anchor="middle" font-family="sans-serif" font-size="14">{escape(label)}</text>')
+        for x, y, label, samples in nodes:
+            svg.append(f'<rect x="{x-100}" y="{y-27}" width="200" height="54" rx="10" fill="#e4effb" stroke="#376aa0"/>')
+            svg.append(f'<text x="{x}" y="{y-3}" text-anchor="middle" font-family="sans-serif" font-size="15">{escape(label)}</text>')
+            svg.append(f'<text x="{x}" y="{y+17}" text-anchor="middle" font-family="sans-serif" font-size="12">n={samples}</text>')
+        svg.append('</svg>')
+        Path(filename).write_text("\n".join(svg), encoding="utf-8")
+        return str(filename)

ebele_entropy_tree-0.1.0/tests/test_tree.py

@@ -0,0 +1,72 @@
+import csv
+import tempfile
+import unittest
+from pathlib import Path
+from xml.etree import ElementTree
+from ebele_tree import DecisionTreeClassifier, entropy, information_gain
+
+class TreeTests(unittest.TestCase):
+    def setUp(self):
+        with (Path(__file__).resolve().parents[1] / "examples/tennis.csv").open() as f:
+            rows = list(csv.DictReader(f))
+        self.y = [r["Play_Tennis"] for r in rows]
+        self.X = [{k:v for k,v in r.items() if k not in ("Day", "Play_Tennis")} for r in rows]
+
+    def test_entropy(self):
+        self.assertEqual(entropy([]), 0)
+        self.assertEqual(entropy(["Yes"] * 3), 0)
+        self.assertEqual(entropy(["Yes", "No"]), 1)
+        self.assertAlmostEqual(entropy(self.y), 0.9402859587)
+
+    def test_known_information_gain(self):
+        self.assertAlmostEqual(information_gain([r["Outlook"] for r in self.X], self.y), 0.2467498198)
+
+    def test_tennis_structure_and_predictions(self):
+        m = DecisionTreeClassifier().fit(self.X, self.y)
+        self.assertEqual(m.tree_["feature"], "Outlook")
+        self.assertEqual(m.tree_["children"]["Sunny"]["feature"], "Humidity")
+        self.assertEqual(m.tree_["children"]["Rain"]["feature"], "Wind")
+        self.assertEqual(m.predict(self.X), self.y)
+
+    def test_depth_limit(self):
+        m = DecisionTreeClassifier(max_depth=0).fit(self.X, self.y)
+        self.assertNotIn("feature", m.tree_)
+        self.assertEqual(m.predict(self.X), ["Yes"] * 14)
+        m = DecisionTreeClassifier(max_depth=1).fit(self.X, self.y)
+        self.assertTrue(all("feature" not in c for c in m.tree_["children"].values()))
+
+    def test_unseen_category_fallback(self):
+        m = DecisionTreeClassifier().fit(self.X, self.y)
+        row = dict(self.X[0], Outlook="Snow")
+        self.assertEqual(m.predict([row]), ["Yes"])
+
+    def test_no_gain_and_min_samples(self):
+        m = DecisionTreeClassifier().fit([{"a":"x"}, {"a":"x"}], ["N", "Y"])
+        self.assertNotIn("feature", m.tree_)
+        m = DecisionTreeClassifier(min_samples_split=15).fit(self.X, self.y)
+        self.assertNotIn("feature", m.tree_)
+
+    def test_svg_is_valid(self):
+        m = DecisionTreeClassifier().fit(self.X, self.y)
+        with tempfile.TemporaryDirectory() as tmp:
+            path = m.export_svg(Path(tmp) / "tree.svg")
+            root = ElementTree.parse(path).getroot()
+            texts = [e.text for e in root.iter() if e.tag.endswith("}text")]
+            self.assertIn("Outlook", texts)
+            self.assertIn("Humidity", texts)
+            self.assertIn("Wind", texts)
+
+    def test_invalid_inputs(self):
+        with self.assertRaises(ValueError):
+            DecisionTreeClassifier().predict(self.X)
+        with self.assertRaises(ValueError):
+            DecisionTreeClassifier(max_depth=-1)
+        with self.assertRaises(ValueError):
+            DecisionTreeClassifier().fit([], [])
+        with self.assertRaises(ValueError):
+            DecisionTreeClassifier().fit([{"a":None}], ["Y"])
+        with self.assertRaises(ValueError):
+            DecisionTreeClassifier().fit([{"a":1}, {"b":2}], ["Y", "N"])
+
+if __name__ == "__main__":
+    unittest.main()