simplex-tree-classifier 0.1.0__tar.gz → 0.2.0__tar.gz

{simplex_tree_classifier-0.1.0/src/simplex_tree_classifier.egg-info → simplex_tree_classifier-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplex-tree-classifier
-Version: 0.1.0
+Version: 0.2.0
 Summary: Hierarchical simplex-tree classifier with barycentric embedding, GPU-accelerated transform, and non-convex boundary pruning.
 Author: Yasmin
 License-Expression: MIT

{simplex_tree_classifier-0.1.0 → simplex_tree_classifier-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplex-tree-classifier"
-version = "0.1.0"
+version = "0.2.0"
 description = "Hierarchical simplex-tree classifier with barycentric embedding, GPU-accelerated transform, and non-convex boundary pruning."
 readme = "README.md"
 requires-python = ">=3.9"

{simplex_tree_classifier-0.1.0 → simplex_tree_classifier-0.2.0}/src/simplex_tree_classifier/__init__.py

@@ -14,7 +14,7 @@ from .plane_equation import PlaneEquation
 from .classifier import SimplexTreeClassifier
 from .backend import get_device
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "SimplexTreeClassifier",

{simplex_tree_classifier-0.1.0 → simplex_tree_classifier-0.2.0}/src/simplex_tree_classifier/classifier.py

@@ -34,6 +34,12 @@ from .convexity import (
 
 
 class SimplexTreeClassifier:
+    # Class-level defaults so instances unpickled from an older version (whose
+    # __dict__ predates these attributes) resolve them to None instead of
+    # raising AttributeError on access.
+    _X_fit: Optional[np.ndarray] = None
+    _y_fit = None
+
     def __init__(self,
                  classifier=None,
                  model=None,
@@ -113,6 +119,12 @@ class SimplexTreeClassifier:
         self._min = None
         self._max = None
 
+        # The raw (pre-normalization) data actually used to fit. In surrogate
+        # mode this is the sampled fill set (plus any points passed to fit),
+        # each labeled by the imitated model. Exposed via ``training_data_``.
+        self._X_fit: Optional[np.ndarray] = None
+        self._y_fit = None
+
         # Result of the automatic same-side pass at the end of fit().
         self.same_side_keys_: Set[frozenset] = set()
 
@@ -185,10 +197,30 @@ class SimplexTreeClassifier:
             return X
         return (X - self._min) / (self._max - self._min + 1e-10)
 
+    @staticmethod
+    def _ensure_in_unit_cube(X: np.ndarray, tol: float = 1e-6) -> None:
+        """Validate that inputs are normalized to ``[0, 1]`` per feature.
+
+        Raises ``ValueError`` when normalization is disabled but the data lies
+        outside the unit cube (so the caller either scales the data or passes
+        ``normalize=True``).
+        """
+        if X.size == 0:
+            return
+        lo = float(np.min(X))
+        hi = float(np.max(X))
+        if lo < -tol or hi > 1.0 + tol:
+            raise ValueError(
+                f"Input features must be normalized to [0, 1] when normalize=False "
+                f"(got value range [{lo:.4g}, {hi:.4g}]). Either min-max scale your "
+                f"data to [0, 1] first, or construct with normalize=True to let the "
+                f"classifier scale it for you."
+            )
+
     # ------------------------------------------------------------------
     # Transform
     # ------------------------------------------------------------------
-    def transform(self, data_points) -> csr_matrix:
+    def transform(self, data_points) -> csr_matrix: # TODO: use pytorch insead of matrix_csr
         """Embed points into sparse barycentric coordinates.
 
         For each point, finds its containing leaf simplex and writes that
@@ -295,6 +327,11 @@ class SimplexTreeClassifier:
         optional - fill points are sampled and labeled by the model; any ``X``
         given is added to the fill set.
 
+        For linear classifiers, redundant same-side subdivisions are merged back
+        automatically at the end (see ``remove_same_side_leaves``): this shrinks
+        the tree without moving the decision boundary. Non-convex pruning stays a
+        separate, explicit ``remove_nonconvex_leaves`` call.
+
         Returns:
             ``self``.
         """
@@ -308,6 +345,15 @@ class SimplexTreeClassifier:
                 X_fit = X_fit.reshape(1, -1)
             y_fit = None if y is None else np.asarray(y)
 
+        # When normalization is off, the data must already live in [0, 1]^d,
+        # otherwise points fall outside the enclosing simplex and embed to
+        # nothing. Fail loudly instead of silently producing empty rows.
+        if not self._normalize_enabled():
+            self._ensure_in_unit_cube(X_fit)
+
+        self._X_fit = X_fit
+        self._y_fit = y_fit
+
         d = X_fit.shape[1]
         self._fit_scaler(X_fit)
         X_norm = self._apply_scaler(X_fit)
@@ -322,9 +368,37 @@ class SimplexTreeClassifier:
             X_transformed = self.transform(X_norm)
             self._fit_estimator(X_transformed, y_fit)
 
-        self._finalize_fit()
+        # Merge back redundant same-side subdivisions (linear only): splits the
+        # boundary never crosses and whose leaves are all one class carry no
+        # boundary information, so collapsing them removes leaves without moving
+        # the decision surface. remove_same_side_leaves() refits and records the
+        # final (empty on convergence) same_side_keys_ itself. For non-linear
+        # classifiers there is nothing to merge, so we just record the state.
+        if self.is_linear_classifier:
+            self.remove_same_side_leaves()
+        else:
+            self._finalize_fit()
         return self
 
+    @property
+    def training_data_(self):
+        """The ``(X, y)`` actually used to fit the classifier.
+
+        In surrogate mode this is the sampled fill set in ``[0, 1]^d`` (plus any
+        points passed to ``fit``), each labeled by the imitated model - i.e. the
+        surrogate training set the package built for you. In dataset mode it is
+        the raw ``X`` (and ``y``) you passed. Raises ``AttributeError`` if the
+        classifier has not been fitted yet.
+        """
+        if self._X_fit is None:
+            raise AttributeError(
+                "training_data_ is unavailable: the classifier was not fitted, or "
+                "it was built by an older version of the package (e.g. a stale "
+                "Jupyter kernel or an old cached pickle). Restart the kernel so the "
+                "updated package is re-imported, delete the cached model, then refit."
+            )
+        return self._X_fit, self._y_fit
+
     def _fit_data_driven(self, X_norm: np.ndarray, y) -> None:
         d = X_norm.shape[1]
         # Start from the root simplex (no uniform subdivision) and grow where
@@ -562,10 +636,10 @@ class SimplexTreeClassifier:
     def find_same_side_simplices(self) -> Set[frozenset]:
         """Find leaf simplices whose siblings all lie on the same boundary side.
 
-        These subdivisions do not contribute to the decision boundary and could
-        be merged back into their parent. Called automatically at the end of
-        ``fit`` for linear classifiers (stored in ``same_side_keys_``); also
-        available directly.
+        These subdivisions do not contribute to the decision boundary and can be
+        merged back into their parent. They are detected *and* merged away
+        automatically at the end of ``fit`` for linear classifiers (see
+        ``remove_same_side_leaves``); this method is also available directly.
         """
         weights, intercept = self._get_weights_and_intercept()
         same_side_keys: Set[frozenset] = set()
@@ -582,6 +656,64 @@ class SimplexTreeClassifier:
                     same_side_keys.add(frozenset(child.vertex_indices))
         return same_side_keys
 
+    def remove_same_side_leaves(self, max_iter: int = 50, refit: bool = True) -> int:
+        """Merge back redundant same-side subdivisions (linear classifiers only).
+
+        A parent split is *same-side* when the decision boundary crosses none of
+        its (leaf) children and they all fall on the same side of it. Such a
+        split adds no information about the boundary, so collapsing it removes
+        leaves without moving the decision surface. Detection is repeated,
+        refitting the classifier between passes, until no same-side splits
+        remain (a new pass can expose parents that only became "all-leaf" after
+        an earlier collapse). Called automatically at the end of ``fit``.
+
+        Args:
+            max_iter: Safety cap on the number of detect/collapse passes.
+            refit: Whether to refit the classifier on the stored training data
+                after each collapse pass.
+
+        Returns:
+            Total number of leaves removed (0 for non-linear classifiers).
+        """
+        if not self.is_linear_classifier:
+            self.same_side_keys_ = set()
+            return 0
+        self._ensure_synced()
+        total = 0
+        try:
+            keys = self.find_same_side_simplices()
+        except Exception:
+            self.same_side_keys_ = set()
+            return 0
+        for _ in range(max_iter):
+            if not keys:
+                break
+            start = len(self.tree.get_leaves())
+            for key in keys:
+                # Collapsing one child un-splits the whole parent; the remaining
+                # sibling keys for that parent then no-op harmlessly.
+                self.tree.remove_by_leaf_key(key)
+            removed = start - len(self.tree.get_leaves())
+            if removed == 0:
+                break
+            total += removed
+            self._mark_dirty()
+            self._sync()
+            if refit and self._X_train_norm is not None and self._y_train is not None:
+                X_transformed = self.transform(self._X_train_norm)
+                self._fit_estimator(X_transformed, self._y_train)
+            # Re-detect on the new (pruned + refit) tree; this doubles as both the
+            # next pass's work-list and the final same-side record, so we never
+            # recompute find_same_side_simplices() redundantly afterwards.
+            try:
+                keys = self.find_same_side_simplices()
+            except Exception:
+                keys = set()
+                break
+        # keys already reflects the current tree/weights (empty on convergence).
+        self.same_side_keys_ = keys
+        return total
+
     def _sampling_epsilon(self, epsilon=None) -> float:
         """Boundary test-point placement fraction, defaulting to ``1 / (d + 1)``."""
         if epsilon is not None:

{simplex_tree_classifier-0.1.0 → simplex_tree_classifier-0.2.0/src/simplex_tree_classifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplex-tree-classifier
-Version: 0.1.0
+Version: 0.2.0
 Summary: Hierarchical simplex-tree classifier with barycentric embedding, GPU-accelerated transform, and non-convex boundary pruning.
 Author: Yasmin
 License-Expression: MIT

{simplex_tree_classifier-0.1.0 → simplex_tree_classifier-0.2.0}/src/simplex_tree_classifier.egg-info/SOURCES.txt

@@ -14,5 +14,4 @@ src/simplex_tree_classifier.egg-info/PKG-INFO
 src/simplex_tree_classifier.egg-info/SOURCES.txt
 src/simplex_tree_classifier.egg-info/dependency_links.txt
 src/simplex_tree_classifier.egg-info/requires.txt
-src/simplex_tree_classifier.egg-info/top_level.txt
-tests/test_api.py
+src/simplex_tree_classifier.egg-info/top_level.txt

simplex_tree_classifier-0.1.0/tests/test_api.py

@@ -1,249 +0,0 @@
-"""Smoke tests for the public SimplexTreeClassifier API.
-
-Run with:  pytest simplex_tree_package/tests
-"""
-
-import numpy as np
-import pytest
-from scipy.sparse import issparse
-from sklearn.svm import LinearSVC, SVC
-
-from simplex_tree_classifier import (
-    SimplexTreeClassifier,
-    SimplexTree,
-    Simplex,
-    make_enclosing_simplex,
-    get_device,
-)
-
-
-def _toy_2d(n=200, seed=0):
-    rng = np.random.default_rng(seed)
-    X = rng.uniform(0, 1, size=(n, 2))
-    y = (X[:, 0] + X[:, 1] > 1.0).astype(int)
-    return X, y
-
-
-def _toy_nd(n=300, d=5, seed=1):
-    rng = np.random.default_rng(seed)
-    X = rng.uniform(0, 1, size=(n, d))
-    y = (X.sum(axis=1) > d / 2.0).astype(int)
-    return X, y
-
-
-# ---------------------------------------------------------------------------
-# Geometry primitives
-# ---------------------------------------------------------------------------
-
-def test_make_enclosing_simplex_2d_matches_classic_triangle():
-    verts = make_enclosing_simplex(2, margin=0.0)
-    assert verts == [(0.0, 0.0), (2.0, 0.0), (0.0, 2.0)]
-
-
-def test_make_enclosing_simplex_contains_unit_cube_corner():
-    d = 4
-    verts = make_enclosing_simplex(d)  # default margin
-    tree = SimplexTree(verts)
-    # Farthest cube corner (1,1,1,1) must be strictly inside.
-    assert tree._point_inside_simplex(tuple([1.0] * d))
-
-
-def test_get_device_returns_torch_device():
-    dev = get_device()
-    assert dev.type in ("cpu", "cuda")
-
-
-# ---------------------------------------------------------------------------
-# Constructor modes
-# ---------------------------------------------------------------------------
-
-def test_constructor_dataset_mode_defaults_to_linear_svc():
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    assert isinstance(clf.classifier, LinearSVC)
-
-
-def test_constructor_surrogate_requires_n_features():
-    with pytest.raises(ValueError):
-        SimplexTreeClassifier(model=lambda X: np.zeros(len(X)))
-
-
-# ---------------------------------------------------------------------------
-# transform / fit / predict
-# ---------------------------------------------------------------------------
-
-def test_transform_rows_sum_to_one_2d():
-    X, _ = _toy_2d()
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    T = clf.transform(X)
-    assert issparse(T)
-    assert T.shape[0] == len(X)
-    row_sums = np.asarray(T.sum(axis=1)).ravel()
-    assert np.allclose(row_sums, 1.0, atol=1e-6)
-
-
-def test_fit_predict_2d_reasonable_accuracy():
-    X, y = _toy_2d()
-    clf = SimplexTreeClassifier(subdivision_levels=3)
-    clf.fit(X, y)
-    preds = clf.predict(X)
-    assert preds.shape == y.shape
-    assert (preds == y).mean() > 0.85
-
-
-def test_fit_predict_nd():
-    X, y = _toy_nd(d=5)
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    clf.fit(X, y)
-    preds = clf.predict(X)
-    assert preds.shape == y.shape
-    assert (preds == y).mean() > 0.7
-
-
-def test_transform_matches_cpu_reference():
-    """GPU/backend embedding must agree with the exact per-simplex embedding."""
-    X, _ = _toy_2d(n=50)
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    clf._ensure_tree(2)
-    T = clf.transform(X).toarray()
-    for i, point in enumerate(X):
-        leaf = clf.tree.find_containing_simplex(tuple(point))
-        emb = leaf._embed_point(tuple(point))
-        expected = np.zeros(len(clf.tree.registry))
-        for k, vid in enumerate(leaf.vertex_indices):
-            expected[vid] = emb[k]
-        assert np.allclose(T[i], expected, atol=1e-6)
-
-
-# ---------------------------------------------------------------------------
-# Data-driven subdivision
-# ---------------------------------------------------------------------------
-
-def test_data_driven_subdivision_grows_tree():
-    X, y = _toy_2d(n=300)
-    clf = SimplexTreeClassifier(subdivision_levels=6,
-                                subdivision_strategy="data_driven",
-                                max_leaves=200)
-    clf.fit(X, y)
-    assert len(clf.leaf_simplexes) > 1
-    assert (clf.predict(X) == y).mean() > 0.85
-
-
-# ---------------------------------------------------------------------------
-# Surrogate mode
-# ---------------------------------------------------------------------------
-
-def test_surrogate_mode_imitates_callable_model():
-    def model(X):
-        X = np.atleast_2d(X)
-        return (X[:, 0] + X[:, 1] > 1.0).astype(int)
-
-    clf = SimplexTreeClassifier(model=model, n_features=2,
-                                subdivision_levels=3, n_fill=1500,
-                                random_state=0)
-    clf.fit()
-    grid = np.random.default_rng(2).uniform(0, 1, size=(200, 2))
-    agreement = (clf.predict(grid) == model(grid)).mean()
-    assert agreement > 0.85
-
-
-def test_surrogate_mode_accepts_predict_object():
-    class Model:
-        def predict(self, X):
-            X = np.atleast_2d(X)
-            return (X[:, 0] > 0.5).astype(int)
-
-    clf = SimplexTreeClassifier(model=Model(), n_features=2,
-                                subdivision_levels=3, random_state=0)
-    clf.fit()
-    assert clf.predict(np.array([[0.9, 0.1], [0.1, 0.9]])).shape == (2,)
-
-
-# ---------------------------------------------------------------------------
-# Geometry queries / renamed & new methods
-# ---------------------------------------------------------------------------
-
-def test_get_simplex_vertices_returns_leaf_vertices():
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    clf._ensure_tree(2)
-    verts = clf.get_simplex_vertices()
-    assert len(verts) == len(clf.leaf_simplexes)
-    assert all(len(v) == 3 for v in verts)  # 2-D leaves are triangles
-
-
-def test_find_containing_simplex_and_is_in_simplex():
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    clf._ensure_tree(2)
-    point = (0.3, 0.3)
-    leaf = clf.find_containing_simplex(point)
-    assert leaf is not None
-    assert clf.is_in_simplex(point, leaf) is True
-    # A point far outside the leaf should not be contained.
-    far = tuple(np.array(leaf.get_vertices_as_tuples()).mean(axis=0) + 100.0)
-    assert clf.is_in_simplex(far, leaf) is False
-
-
-def test_find_adjacent_simplexes_share_a_face():
-    clf = SimplexTreeClassifier(subdivision_levels=2)
-    clf._ensure_tree(2)
-    leaf = clf.leaf_simplexes[0]
-    neighbors = clf.find_adjacent_simplexes(leaf)
-    for nb in neighbors:
-        shared = set(leaf.vertex_indices).intersection(nb.vertex_indices)
-        assert len(shared) >= leaf.dimension
-
-
-# ---------------------------------------------------------------------------
-# Decision-boundary analysis
-# ---------------------------------------------------------------------------
-
-def test_identify_crossing_simplices_linear():
-    X, y = _toy_2d()
-    clf = SimplexTreeClassifier(subdivision_levels=3)
-    clf.fit(X, y)
-    crossing = clf.identify_crossing_simplices()
-    assert isinstance(crossing, list)
-    assert len(crossing) > 0
-    assert "simplex" in crossing[0] and "vertices" in crossing[0]
-
-
-def test_identify_crossing_simplices_nonlinear_fallback():
-    X, y = _toy_2d()
-    clf = SimplexTreeClassifier(classifier=SVC(kernel="rbf", C=10),
-                                subdivision_levels=3)
-    clf.fit(X, y)
-    crossing = clf.identify_crossing_simplices()
-    assert isinstance(crossing, list)
-
-
-def test_same_side_computed_automatically_after_fit():
-    X, y = _toy_2d()
-    clf = SimplexTreeClassifier(subdivision_levels=3)
-    clf.fit(X, y)
-    # Attribute exists and is a set (guarded to linear classifiers).
-    assert isinstance(clf.same_side_keys_, set)
-
-
-# ---------------------------------------------------------------------------
-# Non-convex pruning
-# ---------------------------------------------------------------------------
-
-def test_remove_nonconvex_leaves_reduces_or_keeps_leaf_count():
-    X, y = _toy_2d(n=400)
-    clf = SimplexTreeClassifier(subdivision_levels=4)
-    clf.fit(X, y)
-    before = len(clf.tree.get_leaves())
-    removed = clf.remove_nonconvex_leaves(criterion="distance",
-                                          removal_factor=0.1,
-                                          max_remove_frac=0.25)
-    after = len(clf.tree.get_leaves())
-    assert removed >= 0
-    assert after == before - removed
-
-
-def test_remove_nonconvex_requires_linear_classifier():
-    X, y = _toy_2d()
-    clf = SimplexTreeClassifier(classifier=SVC(kernel="rbf"),
-                                subdivision_levels=2)
-    clf.fit(X, y)
-    with pytest.raises(AttributeError):
-        clf.remove_nonconvex_leaves()