treecf 0.2.2__tar.gz → 0.2.3__tar.gz

{treecf-0.2.2 → treecf-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: treecf
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{treecf-0.2.2 → treecf-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "treecf"
-version = "0.2.2"
+version = "0.2.3"
 description = "Constrained, threshold-aware counterfactual explanations for tree ensembles (XGBoost, LightGBM, CatBoost, sklearn) — fast Rust genetic search, exact optimality proofs, certified infeasibility, and recourse regions."
 readme = "README.md"
 license = { text = "MIT" }

{treecf-0.2.2 → treecf-0.2.3}/rust/Cargo.lock

@@ -419,7 +419,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "treecf-core"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "numpy",
  "pyo3",

{treecf-0.2.2 → treecf-0.2.3}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "treecf-core"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 # f64::next_down (cells.rs) stabilized in 1.86; pyo3 0.29 needs 1.83
 rust-version = "1.86"

{treecf-0.2.2 → treecf-0.2.3}/rust/src/exact/search.rs

@@ -1053,19 +1053,18 @@ pub fn solve_exact(
     }
 
     completed = completed && dropped_floor >= incumbent_cost;
-    let lower_bound;
-    let proof;
-    if completed {
-        lower_bound = match incumbent_row {
+    let (lower_bound, proof) = if completed {
+        let bound = match incumbent_row {
             None => f64::INFINITY,
             Some(_) if gap == 0.0 => incumbent_cost,
             Some(_) => incumbent_cost / (1.0 + gap),
         };
-        proof = if gap > 0.0 && gap_prune_fired {
+        let label = if gap > 0.0 && gap_prune_fired {
             "optimal_within_gap"
         } else {
             "optimal"
         };
+        (bound, label)
     } else {
         let mut open_view = f64::INFINITY;
         if !ctx.order.is_empty() {
@@ -1081,9 +1080,11 @@ pub fn solve_exact(
         } else {
             dropped_floor
         };
-        lower_bound = py_min(py_min(open_view, incumbent_cost), set_aside_view);
-        proof = "heuristic";
-    }
+        (
+            py_min(py_min(open_view, incumbent_cost), set_aside_view),
+            "heuristic",
+        )
+    };
 
     let mut snapped: Vec<usize> = Vec::new();
     for (level, chosen_state) in incumbent_states.iter().flatten().enumerate() {

{treecf-0.2.2 → treecf-0.2.3}/src/treecf/__init__.py

@@ -28,7 +28,7 @@ from treecf.plausibility import Plausibility
 from treecf.regions import RecourseRegion
 from treecf.targets import Target
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 __all__ = [
     "AllowMissing",

{treecf-0.2.2 → treecf-0.2.3}/src/treecf/ir/parsers/sklearn.py

@@ -96,8 +96,40 @@ def _parse_hist_gradient_boosting(model: Any) -> EnsembleIR:
     )
 
 
+def _effective_le_threshold(t: float) -> float:
+    """The float64 boundary of sklearn's float32 input cast, exactly.
+
+    sklearn ``tree_``-based ensembles route ``float32(x) <= float64(t)`` —
+    the input is cast to float32 (round-to-nearest-even) before the
+    comparison. The IR evaluates in float64, so the stored threshold must be
+    the largest float64 ``T`` with ``float32(T) <= t``; then ``x <= T``
+    reproduces the native routing for *every* float64 ``x``, including points
+    exactly on split boundaries — where a counterfactual search naturally
+    lands. (Verified by a 138k-probe property sweep and the unquantized
+    conformance tests.)
+
+    Construction: let ``f`` be the largest float32 with ``f <= t`` and ``s``
+    its float32 successor; every ``x`` below their float64 midpoint rounds to
+    ``<= f``. The midpoint itself rounds half-to-even: it belongs to the left
+    side exactly when it rounds back to ``f``.
+    """
+    f32 = np.float32(t)
+    if float(f32) > t:
+        f32 = np.nextafter(f32, np.float32(-np.inf))
+    succ = np.nextafter(f32, np.float32(np.inf))
+    mid = (float(f32) + float(succ)) / 2.0
+    if float(np.float32(mid)) == float(f32):
+        return mid
+    return float(np.nextafter(mid, -np.inf))
+
+
 def _tree_from_arrays(tree: Any, scale: float, classifier: bool) -> Tree:
-    """Convert a fitted ``sklearn.tree._tree.Tree`` to IR nodes (LE convention)."""
+    """Convert a fitted ``sklearn.tree._tree.Tree`` to IR nodes (LE convention).
+
+    Thresholds are re-expressed on the float64 grid via
+    :func:`_effective_le_threshold` so the IR's float64 routing matches
+    sklearn's float32-cast routing bit-for-bit.
+    """
     left = tree.children_left
     right = tree.children_right
     feature = tree.feature
@@ -120,7 +152,7 @@ def _tree_from_arrays(tree: Any, scale: float, classifier: bool) -> Tree:
                 Node(
                     node_id=i,
                     feature=int(feature[i]),
-                    threshold=float(threshold[i]),
+                    threshold=_effective_le_threshold(float(threshold[i])),
                     op=SplitOp.LE,
                     missing_left=missing_left,
                     left=int(left[i]),
@@ -183,7 +215,7 @@ def parse_isolation_forest(model: Any) -> EnsembleIR:
                     Node(
                         node_id=i,
                         feature=int(tree.feature[i]),
-                        threshold=float(tree.threshold[i]),
+                        threshold=_effective_le_threshold(float(tree.threshold[i])),
                         op=SplitOp.LE,
                         missing_left=None,
                         left=int(tree.children_left[i]),