zedstat 0.0.153__tar.gz → 0.2.0__tar.gz

{zedstat-0.0.153/zedstat.egg-info → zedstat-0.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: zedstat
-Version: 0.0.153
+Version: 0.2.0
 Summary: Statistics tools for ML models and deployment
 Home-page: https://github.com/zeroknowledgediscovery/zedstat
-Download-URL: https://github.com/zeroknowledgediscovery/zedstat/archive/0.0.153.tar.gz
+Download-URL: https://github.com/zeroknowledgediscovery/zedstat/archive/0.2.0.tar.gz
 Author: zed.uchicago.edu
 Author-email: ishanu@uchicago.edu
 License: LICENSE

zedstat-0.2.0/tests/test_ci_logratio.py

@@ -0,0 +1,39 @@
+import unittest
+import numpy as np
+import pandas as pd
+from zedstat.ci_logratio import ppv_logratio_ci, lr_logratio_ci
+
+class TestLogRatioCI(unittest.TestCase):
+    def test_ppv_formula_and_bracketing(self):
+        roc = pd.DataFrame({'fpr':[0, 0.02, 0.05,0.2], 'tpr':[0,0.15,0.5,0.9]})
+        out=ppv_logratio_ci(roc, positive_samples=400, negative_samples=2000,
+                            prevalence=.1, min_tp=10, min_fp=10, smooth_sigma=2)
+        self.assertTrue(np.isnan(out['ppv_logratio_lower'].iloc[0]))
+        center=.1*.5/(.1*.5+.9*.05)
+        self.assertAlmostEqual(center, float(out['ppv'].iloc[2]) if 'ppv' in out else center)
+        row=out.iloc[2]
+        self.assertTrue(row['ppv_logratio_lower'] < center < row['ppv_logratio_upper'])
+
+    def test_lr_asymptotic_intervals_enclose_nominal_and_preserve_nan(self):
+        counts = pd.DataFrame({'TP':[5,30,100,250],'FP':[2,20,90,160],
+                               'FN':[395,370,300,150], 'TN':[1998,1980,1910,1840]})
+        counts['LR+'] = (counts['TP']/400)/(counts['FP']/2000)
+        counts['LR-'] = (counts['FN']/400)/(counts['TN']/2000)
+        a=lr_logratio_ci(counts, smooth_sigma=0)
+        b=lr_logratio_ci(counts, smooth_sigma=1.8)
+        self.assertTrue(np.isnan(a['LR+_logratio_lower'].iloc[0]))
+        for metric in ('LR+', 'LR-'):
+            np.testing.assert_array_equal(a[f'{metric}_logratio_lower'],b[f'{metric}_logratio_lower'])
+            valid=b[f'{metric}_logratio_lower_display'].notna()
+            self.assertTrue((b.loc[valid, f'{metric}_logratio_lower_display'] <= b.loc[valid,metric]).all())
+            self.assertTrue((b.loc[valid,metric] <= b.loc[valid,f'{metric}_logratio_upper_display']).all())
+
+    def test_boundary_support_is_not_reconstructed(self):
+        roc=pd.DataFrame({'fpr':[0,0.005,.01,.02], 'tpr':[0,.1,.2,.4]})
+        out=ppv_logratio_ci(roc,positive_samples=200,negative_samples=2000,prevalence=.1,
+                            min_fp=20,smooth_sigma=10)
+        self.assertTrue(np.isnan(out['ppv_logratio_lower_display'].iloc[0]))
+        self.assertTrue(np.isnan(out['ppv_logratio_lower_display'].iloc[1]))
+        self.assertTrue(np.isfinite(out['ppv_logratio_lower_display'].iloc[2]))
+
+if __name__ == '__main__': unittest.main()

zedstat-0.2.0/tests/test_getbounds_current_geometry.py

@@ -0,0 +1,83 @@
+import inspect
+import unittest
+
+import numpy as np
+import pandas as pd
+from pandas.testing import assert_frame_equal
+
+from zedstat import zedstat
+
+
+class GetBoundsCurrentGeometryTest(unittest.TestCase):
+    @staticmethod
+    def _make_zt():
+        # Deliberately fluctuating ROC so convexification materially changes it.
+        roc = pd.DataFrame(
+            {
+                "fpr": [0.0, 0.04, 0.08, 0.13, 0.20, 0.31, 0.44, 0.60, 0.78, 1.0],
+                "tpr": [0.0, 0.31, 0.27, 0.53, 0.48, 0.70, 0.66, 0.84, 0.88, 1.0],
+            }
+        )
+        zt = zedstat.processRoc(
+            df=roc,
+            total_samples=1200,
+            positive_samples=600,
+            alpha=0.01,
+            prevalence=0.5,
+        )
+        zt.smooth(STEP=0.001, interpolate=True, convexify=True)
+        zt.allmeasures(interpolate=False)
+        return zt
+
+    def test_getbounds_defaults_to_current_geometry(self):
+        zt = self._make_zt()
+        before = zt.get().copy(deep=True)
+        auc_before = zt.auc(alpha=0.05)[0]
+
+        zt.getBounds()
+
+        after = zt.get().copy(deep=True)
+        auc_after = zt.auc(alpha=0.05)[0]
+
+        # getBounds is side-effect free with respect to the nominal ROC.
+        assert_frame_equal(before, after, check_exact=True)
+        self.assertAlmostEqual(auc_before, auc_after, places=14)
+
+        self.assertEqual(zt.df_measure_bounds_["geometry"], "current")
+        self.assertIn("L", zt.df_lim)
+        self.assertIn("U", zt.df_lim)
+
+        nominal = zt.get()["tpr"].to_numpy(dtype=float)
+        lower = zt.df_lim["L"]["tpr"].to_numpy(dtype=float)
+        upper = zt.df_lim["U"]["tpr"].to_numpy(dtype=float)
+
+        finite = np.isfinite(nominal) & np.isfinite(lower) & np.isfinite(upper)
+        self.assertTrue(np.all(lower[finite] <= nominal[finite] + 1e-12))
+        self.assertTrue(np.all(upper[finite] >= nominal[finite] - 1e-12))
+
+        # Display ROC limits follow monotone ROC geometry after smoothing.
+        self.assertTrue(np.all(np.diff(lower[np.isfinite(lower)]) >= -1e-12))
+        self.assertTrue(np.all(np.diff(upper[np.isfinite(upper)]) >= -1e-12))
+
+    def test_empirical_geometry_remains_available(self):
+        zt = self._make_zt()
+        before = zt.get().copy(deep=True)
+
+        zt.getBounds(geometry="empirical")
+
+        assert_frame_equal(before, zt.get(), check_exact=True)
+        self.assertEqual(zt.df_measure_bounds_["geometry"], "empirical")
+
+    def test_geometry_parameter_is_visible(self):
+        sig = inspect.signature(zedstat.processRoc.getBounds)
+        self.assertIn("geometry", sig.parameters)
+        self.assertEqual(sig.parameters["geometry"].default, "current")
+
+    def test_invalid_geometry_raises(self):
+        zt = self._make_zt()
+        with self.assertRaises(ValueError):
+            zt.getBounds(geometry="banana")
+
+
+if __name__ == "__main__":
+    unittest.main()

zedstat-0.2.0/tests/test_getbounds_preserves_nominal.py

@@ -0,0 +1,55 @@
+import unittest
+
+import numpy as np
+import pandas as pd
+from pandas.testing import assert_frame_equal
+
+from zedstat import zedstat
+
+
+class GetBoundsNominalInvariantTest(unittest.TestCase):
+    def test_getbounds_preserves_convexified_nominal_roc(self):
+        # Deliberately fluctuating ROC so convexification materially changes it.
+        roc = pd.DataFrame(
+            {
+                "fpr": [0.0, 0.05, 0.10, 0.18, 0.25, 0.40, 0.55, 0.75, 1.0],
+                "tpr": [0.0, 0.36, 0.31, 0.60, 0.54, 0.78, 0.74, 0.91, 1.0],
+            }
+        )
+
+        zt = zedstat.processRoc(
+            df=roc,
+            total_samples=1000,
+            positive_samples=500,
+            alpha=0.01,
+            prevalence=0.5,
+        )
+        zt.smooth(STEP=0.001, interpolate=True, convexify=True)
+        zt.allmeasures(interpolate=False)
+
+        before = zt.get().copy(deep=True)
+        auc_before = zt.auc(alpha=0.05)[0]
+
+        # Confirm the fixture actually exercises the ROCCH path.
+        fpr = before.index.to_numpy(dtype=float)
+        tpr = before["tpr"].to_numpy(dtype=float)
+        dx = np.diff(fpr)
+        dy = np.diff(tpr)
+        slopes = dy / dx
+        self.assertTrue(np.all(dx > 0))
+        self.assertTrue(np.all(dy >= -1e-12))
+        self.assertTrue(np.all(np.diff(slopes) <= 1e-9))
+
+        zt.getBounds()
+
+        after = zt.get().copy(deep=True)
+        auc_after = zt.auc(alpha=0.05)[0]
+
+        assert_frame_equal(before, after, check_exact=True)
+        self.assertAlmostEqual(auc_before, auc_after, places=14)
+        self.assertIn("L", zt.df_lim)
+        self.assertIn("U", zt.df_lim)
+
+
+if __name__ == "__main__":
+    unittest.main()

zedstat-0.2.0/tests/test_lr_ci.py

@@ -0,0 +1,54 @@
+"""Regression tests for zedstat LR frontier confidence intervals."""
+import unittest
+import numpy as np
+import pandas as pd
+from pandas.testing import assert_frame_equal
+
+from zedstat.lr_ci import lr_curve_ci_from_scores
+
+
+class TestLRCurveCI(unittest.TestCase):
+    @staticmethod
+    def mock(n_pos=350, n_neg=1800, seed=8):
+        rng = np.random.default_rng(seed)
+        positive = rng.beta(4, 3, n_pos)
+        negative = rng.beta(2, 5, n_neg)
+        return pd.DataFrame({"target": np.r_[np.ones(n_pos), np.zeros(n_neg)],
+                             "predicted_risk": np.r_[positive, negative]})
+
+    def test_ci_encloses_nominal_and_supports_all_points(self):
+        data = self.mock()
+        out = lr_curve_ci_from_scores(data, n_boot=400, random_state=1)
+        self.assertGreater(len(out), 10)
+        self.assertTrue((out[["TP", "FP", "FN", "TN"]].min(axis=1) >= 10).all())
+        self.assertTrue(out["LR-"].is_monotonic_increasing)
+        self.assertTrue(out["LR+"].is_monotonic_increasing)
+        for metric in ("LR+", "LR-"):
+            complete = out[[f"{metric}_lower", f"{metric}_upper"]].notna().all(axis=1)
+            self.assertGreater(complete.sum(), 0)
+            self.assertTrue((out.loc[complete, f"{metric}_lower"] <= out.loc[complete, metric]).all())
+            self.assertTrue((out.loc[complete, metric] <= out.loc[complete, f"{metric}_upper"]).all())
+
+    def test_reproducible_and_smoothing_does_not_modify_raw_ci(self):
+        data = self.mock()
+        a = lr_curve_ci_from_scores(data, n_boot=400, random_state=19)
+        b = lr_curve_ci_from_scores(data, n_boot=400, random_state=19, smooth_sigma=1.2)
+        for col in ["LR+", "LR-", "LR+_lower", "LR+_upper", "LR-_lower", "LR-_upper"]:
+            np.testing.assert_array_equal(a[col].to_numpy(), b[col].to_numpy())
+        self.assertTrue(np.isfinite(b["LR+_lower_display"]).sum() > 0)
+
+    def test_few_positives_are_handled_without_endpoint_extension(self):
+        data = self.mock(n_pos=45, n_neg=1600, seed=93)
+        out = lr_curve_ci_from_scores(data, n_boot=400, random_state=22)
+        self.assertGreater(len(out), 0)
+        self.assertTrue((out[["TP", "FP", "FN", "TN"]].min(axis=1) >= 10).all())
+        for end in ("lower", "upper"):
+            self.assertTrue(out[f"LR+_{end}"].isna().equals(out[f"LR+_{end}_display"].isna()))
+
+    def test_reject_insufficient_counts(self):
+        with self.assertRaisesRegex(ValueError, "Too few"):
+            lr_curve_ci_from_scores(self.mock(n_pos=15, n_neg=1000), n_boot=400)
+
+
+if __name__ == "__main__":
+    unittest.main()

zedstat-0.2.0/version.py

@@ -0,0 +1 @@
+__version__ = '0.2.0'

zedstat-0.2.0/zedstat/__init__.py

@@ -0,0 +1,230 @@
+"""
+# zedstat
+
+Utilities for uncertainty quantification and deployment of ML models.
+
+Installation::
+
+    pip install zedstat
+
+Useful for calculation of likelihood ratios, confidence intervals on AUC,
+and simple performance interpretation.
+"""
+
+from functools import wraps
+import inspect
+
+import numpy as np
+import pandas as pd
+
+# Import the public submodule during package initialization so every supported
+# import style receives the same processRoc behavior.
+from . import zedstat as zedstat
+
+
+def _bounds_on_current_geometry(self, nominal_df, prevalence):
+    """Re-center empirical pointwise uncertainty on the current ROC geometry.
+
+    The uncertainty widths are still estimated from the raw empirical ROC by
+    processRoc.getBounds(). This helper only changes the display geometry:
+    those empirical lower/upper distances are interpolated to the current FPR
+    grid and re-centered on the current (possibly smoothed/convexified) ROC.
+
+    This avoids treating a convex-hull/interpolated TPR as if it were itself an
+    independent binomial observation while ensuring the displayed confidence
+    band follows the ROC that the user actually requested.
+    """
+    info = getattr(self, "df_measure_bounds_", None) or {}
+    nominal_emp = info.get("nominal_empirical")
+    lower_emp = info.get("L_empirical")
+    upper_emp = info.get("U_empirical")
+
+    if nominal_emp is None or lower_emp is None or upper_emp is None:
+        return
+
+    # Recompute derived measures from the current FPR/TPR coordinates so the
+    # display nominal is internally consistent with the smoothed ROC.
+    nominal = self._compute_measures(
+        nominal_df,
+        prevalence=float(prevalence),
+        apply_ppv_isotonic=True,
+    )
+    target_index = nominal.index.to_numpy(dtype=float)
+
+    cols = [
+        c
+        for c in ["tpr", "ppv", "acc", "npv", "LR+", "LR-"]
+        if c in nominal.columns
+        and c in nominal_emp.columns
+        and c in lower_emp.columns
+        and c in upper_emp.columns
+    ]
+
+    # Empirical one-sided uncertainty widths around the raw nominal curve.
+    lower_gap = pd.DataFrame(index=nominal_emp.index.copy())
+    upper_gap = pd.DataFrame(index=nominal_emp.index.copy())
+    lower_gap.index.name = self.fprcol
+    upper_gap.index.name = self.fprcol
+
+    for col in cols:
+        n = pd.to_numeric(nominal_emp[col], errors="coerce").to_numpy(dtype=float)
+        lo = pd.to_numeric(lower_emp[col], errors="coerce").to_numpy(dtype=float)
+        hi = pd.to_numeric(upper_emp[col], errors="coerce").to_numpy(dtype=float)
+
+        lower_gap[col] = np.where(
+            np.isfinite(n) & np.isfinite(lo),
+            np.maximum(n - lo, 0.0),
+            np.nan,
+        )
+        upper_gap[col] = np.where(
+            np.isfinite(n) & np.isfinite(hi),
+            np.maximum(hi - n, 0.0),
+            np.nan,
+        )
+
+    lower_gap = zedstat._numeric_interp_frame_to_target_index(
+        lower_gap,
+        target_index,
+        index_name=self.fprcol,
+    )
+    upper_gap = zedstat._numeric_interp_frame_to_target_index(
+        upper_gap,
+        target_index,
+        index_name=self.fprcol,
+    )
+
+    lower = nominal.copy(deep=True)
+    upper = nominal.copy(deep=True)
+
+    for col in cols:
+        n = pd.to_numeric(nominal[col], errors="coerce").to_numpy(dtype=float)
+        lg = pd.to_numeric(lower_gap[col], errors="coerce").to_numpy(dtype=float)
+        ug = pd.to_numeric(upper_gap[col], errors="coerce").to_numpy(dtype=float)
+        lower[col] = n - lg
+        upper[col] = n + ug
+
+    # Probability-like quantities are bounded by [0, 1].
+    for col in ["tpr", "ppv", "acc", "npv"]:
+        if col in lower.columns:
+            lower[col] = np.clip(
+                pd.to_numeric(lower[col], errors="coerce").to_numpy(dtype=float),
+                0.0,
+                1.0,
+            )
+            upper[col] = np.clip(
+                pd.to_numeric(upper[col], errors="coerce").to_numpy(dtype=float),
+                0.0,
+                1.0,
+            )
+
+    # ROC display limits should respect monotonic ROC geometry. We do not
+    # independently convex-hull the limits because that would alter their
+    # statistical interpretation more aggressively.
+    if "tpr" in lower.columns:
+        lower["tpr"] = np.maximum.accumulate(
+            pd.to_numeric(lower["tpr"], errors="coerce").to_numpy(dtype=float)
+        )
+        upper["tpr"] = np.maximum.accumulate(
+            pd.to_numeric(upper["tpr"], errors="coerce").to_numpy(dtype=float)
+        )
+
+    lower, upper = zedstat._enforce_bounds_around_nominal(
+        nominal,
+        lower,
+        upper,
+        cols=cols,
+    )
+
+    nominal = zedstat._apply_lr_floor(
+        nominal,
+        lr_fpr_floor=self.lr_fpr_floor,
+        lr_sp_floor=getattr(self, "lr_sp_floor", self.lr_fpr_floor),
+        fprcol=self.fprcol,
+    )
+    lower = zedstat._apply_lr_floor(
+        lower,
+        lr_fpr_floor=self.lr_fpr_floor,
+        lr_sp_floor=getattr(self, "lr_sp_floor", self.lr_fpr_floor),
+        fprcol=self.fprcol,
+    )
+    upper = zedstat._apply_lr_floor(
+        upper,
+        lr_fpr_floor=self.lr_fpr_floor,
+        lr_sp_floor=getattr(self, "lr_sp_floor", self.lr_fpr_floor),
+        fprcol=self.fprcol,
+    )
+
+    self.df_lim["L"] = lower
+    self.df_lim["U"] = upper
+    self.df_measure_bounds_["nominal_display"] = nominal
+    self.df_measure_bounds_["L_display"] = lower
+    self.df_measure_bounds_["U_display"] = upper
+    self.df_measure_bounds_["geometry"] = "current"
+
+
+def _install_getbounds_geometry_guard():
+    """Keep the nominal ROC invariant and align display bounds when requested."""
+    original = zedstat.processRoc.getBounds
+
+    # If an older package reload left the nominal-only guard in place, unwrap it
+    # before installing the newer geometry-aware wrapper.
+    if getattr(original, "_bounds_geometry_v2", False):
+        return
+    if getattr(original, "_preserves_nominal_df", False) and hasattr(original, "__wrapped__"):
+        original = original.__wrapped__
+
+    original_sig = inspect.signature(original)
+
+    @wraps(original)
+    def guarded_getBounds(self, *args, geometry="current", **kwargs):
+        geometry = str(geometry).lower()
+        if geometry not in {"current", "empirical"}:
+            raise ValueError("geometry must be 'current' or 'empirical'")
+
+        nominal_df = self.df.copy(deep=True)
+        bound = original_sig.bind_partial(self, *args, **kwargs)
+        prevalence = bound.arguments.get("prevalence", self.prevalence)
+
+        try:
+            result = original(self, *args, **kwargs)
+
+            if geometry == "current":
+                if prevalence is None:
+                    raise ValueError("prevalence undefined")
+                _bounds_on_current_geometry(
+                    self,
+                    nominal_df=nominal_df,
+                    prevalence=prevalence,
+                )
+            else:
+                self.df_measure_bounds_["geometry"] = "empirical"
+
+            return result
+        finally:
+            # Bounds are side products. The nominal/display ROC selected by
+            # smooth()/usample() must never be replaced by getBounds().
+            self.df = nominal_df
+
+    # Preserve introspection while exposing the new keyword-only option.
+    params = list(original_sig.parameters.values())
+    params.append(
+        inspect.Parameter(
+            "geometry",
+            kind=inspect.Parameter.KEYWORD_ONLY,
+            default="current",
+        )
+    )
+    guarded_getBounds.__signature__ = original_sig.replace(parameters=params)
+    guarded_getBounds._preserves_nominal_df = True
+    guarded_getBounds._bounds_geometry_v2 = True
+    zedstat.processRoc.getBounds = guarded_getBounds
+
+
+_install_getbounds_geometry_guard()
+del _install_getbounds_geometry_guard
+
+# Pointwise score-level LR confidence intervals and fill-only plot helper.
+from .lr_ci import lr_curve_ci_from_scores, plot_lr_ci_fill
+
+# Score-based CI extensions (pointwise; display smoothing is non-inferential)
+from .pr_ci import precision_recall_ci_from_scores, plot_precision_recall_ci_fill

zedstat-0.2.0/zedstat/ci_logratio.py

@@ -0,0 +1,166 @@
+"""Approximate pointwise log-ratio CIs and separate display-only smoothing.
+
+Statistical scope:
+- Large-sample log-delta intervals at fixed score thresholds, conditional on
+  the validation sample's positive/negative totals and a fixed target prevalence.
+- No simultaneous confidence-band or data-driven frontier selection guarantee.
+- When rates are read from a smoothed ROC, inference is approximate; for a
+  rigorous coverage claim compute the estimates on empirical thresholds first.
+- *_display columns are *cosmetic*, not separately calibrated 95% intervals.
+
+No extrapolation, clipping of large widths, or empirical-CI shrinkage is used.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.ndimage import gaussian_filter1d
+from scipy.special import expit, logit
+from scipy.stats import norm
+
+
+def _smooth_log_widths(nominal, lower, upper, *, sigma=0.0, scale="log"):
+    """Smooth lower/upper distances around nominal, respecting NaN gaps.
+
+    log for positive LR, logit for probability. Never changes nominal, never
+    extrapolates or bridges a missing interval. The outputs are display-only.
+    """
+    y = np.asarray(nominal, dtype=float)
+    lo = np.asarray(lower, dtype=float)
+    hi = np.asarray(upper, dtype=float)
+    d_lo = np.full(y.shape, np.nan)
+    d_hi = np.full(y.shape, np.nan)
+    if scale == "logit":
+        transform, inv = logit, expit
+        valid = (np.isfinite(y) & np.isfinite(lo) & np.isfinite(hi)
+                 & (y > 0) & (y < 1) & (lo > 0) & (lo < 1)
+                 & (hi > 0) & (hi < 1) & (lo <= y) & (y <= hi))
+    elif scale == "log":
+        transform, inv = np.log, np.exp
+        valid = (np.isfinite(y) & np.isfinite(lo) & np.isfinite(hi)
+                 & (y > 0) & (lo > 0) & (hi > 0)
+                 & (lo <= y) & (y <= hi))
+    else:
+        raise ValueError("scale must be 'log' or 'logit'")
+    indices = np.flatnonzero(valid)
+    if not len(indices):
+        return d_lo, d_hi
+    for seg in np.split(indices, np.flatnonzero(np.diff(indices) > 1) + 1):
+        center = transform(y[seg])
+        lower_width = np.maximum(center - transform(lo[seg]), 0)
+        upper_width = np.maximum(transform(hi[seg]) - center, 0)
+        if sigma > 0 and len(seg) >= 3:
+            lower_width = gaussian_filter1d(lower_width, sigma=float(sigma), mode="reflect")
+            upper_width = gaussian_filter1d(upper_width, sigma=float(sigma), mode="reflect")
+        d_lo[seg] = inv(center - lower_width)
+        d_hi[seg] = inv(center + upper_width)
+    return d_lo, d_hi
+
+
+def ppv_logratio_ci(
+    roc: pd.DataFrame,
+    *,
+    positive_samples: int,
+    negative_samples: int,
+    prevalence: float,
+    confidence: float = 0.95,
+    min_tp: int = 10,
+    min_fp: int = 10,
+    smooth_sigma: float = 0.0,
+) -> pd.DataFrame:
+    """Return approximate pointwise PPV CIs on a ROC-derived data frame.
+
+    Under fixed-prevalence transport, logit(PPV) = logit(pi) + log(TPR/FPR).
+    Assuming independent binomial TPR/FPR sampling, delta-method variance is
+      Var(log(TPR/FPR)) ≈ 1/TP - 1/n_pos + 1/FP - 1/n_neg.
+
+    The nominal PPV column, if supplied, is used as the center; when it has
+    been isotonic-corrected, CIs are *approximate display-aligned* intervals,
+    not a coverage assertion for a constrained estimator.
+    """
+    if not 0 < prevalence < 1 or not 0 < confidence < 1:
+        raise ValueError("prevalence and confidence must be in (0,1)")
+    if min(positive_samples, negative_samples) <= 0 or min_tp < 1 or min_fp < 1:
+        raise ValueError("Sample sizes must be positive and min counts >=1")
+    if smooth_sigma < 0:
+        raise ValueError("smooth_sigma must be >= 0")
+    work = roc.copy()
+    fpr = (pd.to_numeric(work["fpr"], errors="coerce").to_numpy(dtype=float)
+           if "fpr" in work.columns else work.index.to_numpy(dtype=float))
+    tpr = pd.to_numeric(work["tpr"], errors="coerce").to_numpy(dtype=float)
+    tp = positive_samples * tpr
+    fp = negative_samples * fpr
+    with np.errstate(invalid="ignore", divide="ignore"):
+        ppv_raw = prevalence*tpr / (prevalence*tpr + (1-prevalence)*fpr)
+    y = (pd.to_numeric(work["ppv"], errors="coerce").to_numpy(dtype=float)
+         if "ppv" in work.columns else ppv_raw)
+    mask = (np.isfinite(y) & (y > 0) & (y < 1) & (tpr > 0) & (fpr > 0)
+            & (fpr <= 1) & (tpr <= 1) & (tp >= min_tp) & (fp >= min_fp))
+    se = np.full(y.shape, np.nan, dtype=float)
+    se[mask] = np.sqrt(np.maximum(
+        1/tp[mask] - 1/positive_samples + 1/fp[mask] - 1/negative_samples, 0))
+    z = norm.ppf(0.5 + confidence/2)
+    lower = np.full(y.shape, np.nan)
+    upper = np.full(y.shape, np.nan)
+    lower[mask] = expit(logit(y[mask]) - z*se[mask])
+    upper[mask] = expit(logit(y[mask]) + z*se[mask])
+    work["ppv_logratio_lower"] = lower
+    work["ppv_logratio_upper"] = upper
+    work["ppv_logratio_se_logit"] = se
+    display_lo, display_hi = _smooth_log_widths(y, lower, upper, sigma=smooth_sigma, scale="logit")
+    work["ppv_logratio_lower_display"] = display_lo
+    work["ppv_logratio_upper_display"] = display_hi
+    work.attrs["ppv_logratio_ci"] = {
+        "confidence": confidence, "method": "fixed_threshold_log_delta_approximation",
+        "min_tp": min_tp, "min_fp": min_fp,
+        "display_sigma": smooth_sigma,
+        "warning": "Display smoothing and ROC isotonic correction can alter nominal coverage"
+    }
+    return work
+
+
+def lr_logratio_ci(
+    curve: pd.DataFrame,
+    *,
+    confidence: float = 0.95,
+    min_count: int = 10,
+    smooth_sigma: float = 0.0,
+) -> pd.DataFrame:
+    """Approximate log-delta 95% LR+ and LR- CIs from observed cell counts.
+
+    SE(log LR+)² = 1/TP - 1/(TP+FN) + 1/FP - 1/(FP+TN)
+    SE(log LR-)² = 1/FN - 1/(TP+FN) + 1/TN - 1/(FP+TN)
+    with nonzero support. Raw and display-smoothed limits are separate.
+    """
+    if not 0 < confidence < 1 or min_count < 1 or smooth_sigma < 0:
+        raise ValueError("Invalid confidence, min_count or smooth_sigma")
+    out = curve.copy()
+    tp, fp, fn, tn = (pd.to_numeric(out[k], errors="coerce").to_numpy(dtype=float)
+                      for k in ("TP", "FP", "FN", "TN"))
+    n_pos, n_neg = tp+fn, fp+tn
+    support = (np.isfinite(tp) & np.isfinite(fp) & np.isfinite(fn) & np.isfinite(tn)
+               & (np.minimum.reduce([tp,fp,fn,tn]) >= min_count)
+               & (n_pos > 0) & (n_neg > 0))
+    z = norm.ppf(0.5 + confidence/2)
+    for metric, a,b in (("LR+",tp,fp),("LR-",fn,tn)):
+        nominal = pd.to_numeric(out[metric], errors="coerce").to_numpy(dtype=float)
+        valid = support & np.isfinite(nominal) & (nominal > 0)
+        se = np.full(nominal.shape, np.nan)
+        se[valid] = np.sqrt(np.maximum(1/a[valid] - 1/n_pos[valid]
+                                       + 1/b[valid] - 1/n_neg[valid], 0))
+        lo, hi = np.full(nominal.shape, np.nan), np.full(nominal.shape, np.nan)
+        lo[valid] = nominal[valid] * np.exp(-z*se[valid])
+        hi[valid] = nominal[valid] * np.exp(z*se[valid])
+        out[f"{metric}_logratio_lower"] = lo
+        out[f"{metric}_logratio_upper"] = hi
+        out[f"{metric}_logratio_se_log"] = se
+        dlo, dhi = _smooth_log_widths(nominal, lo, hi, sigma=smooth_sigma, scale="log")
+        out[f"{metric}_logratio_lower_display"] = dlo
+        out[f"{metric}_logratio_upper_display"] = dhi
+    out.attrs["lr_logratio_ci"] = {
+        "confidence": confidence, "method": "fixed_threshold_log_delta_approximation",
+        "min_count": min_count, "display_sigma": smooth_sigma,
+        "warning": "Not simultaneous or post-frontier-selection adjusted; display smoothing not calibrated"
+    }
+    return out

zedstat-0.2.0/zedstat/lr_ci.py

@@ -0,0 +1,190 @@
+"""Pointwise likelihood-ratio confidence intervals from raw scores.
+
+This module deliberately does not use interpolated ROC or getBounds() tables.
+CIs are estimated at fixed score thresholds using case/control binomial
+resampling; they do not account for frontier selection and are not simultaneous
+confidence bands. Display smoothing is separated from raw inference.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+_METRICS = ("LR+", "LR-")
+_CI_COLS = tuple(f"{m}_{lim}" for m in _METRICS for lim in ("lower", "upper"))
+
+
+def _smooth_lr_widths(curve: pd.DataFrame, sigma: float) -> pd.DataFrame:
+    """Add *_lower_display/*_upper_display (not inferential CIs).
+
+    Smooth log-relative widths only within consecutive fully finite segments.
+    Never bridge invalid thresholds, extrapolate, or modify nominal values.
+    """
+    out = curve.copy()
+    if sigma <= 0:
+        for m in _METRICS:
+            for end in ("lower", "upper"):
+                out[f"{m}_{end}_display"] = out[f"{m}_{end}"]
+        return out
+
+    from scipy.ndimage import gaussian_filter1d
+
+    for metric in _METRICS:
+        nominal = out[metric].to_numpy(dtype=float)
+        lo = out[f"{metric}_lower"].to_numpy(dtype=float)
+        hi = out[f"{metric}_upper"].to_numpy(dtype=float)
+        lo_display = np.full(len(out), np.nan, dtype=float)
+        hi_display = np.full(len(out), np.nan, dtype=float)
+        valid = (np.isfinite(nominal) & (nominal > 0) &
+                 np.isfinite(lo) & (lo > 0) &
+                 np.isfinite(hi) & (hi > 0) &
+                 (lo <= nominal) & (nominal <= hi))
+        indices = np.flatnonzero(valid)
+        if len(indices):
+            for segment in np.split(indices, np.flatnonzero(np.diff(indices) > 1) + 1):
+                low_gap = np.log(nominal[segment] / lo[segment])
+                high_gap = np.log(hi[segment] / nominal[segment])
+                if len(segment) >= 4:
+                    low_gap = gaussian_filter1d(low_gap, sigma=sigma, mode="nearest")
+                    high_gap = gaussian_filter1d(high_gap, sigma=sigma, mode="nearest")
+                lo_display[segment] = nominal[segment] * np.exp(-np.maximum(low_gap, 0))
+                hi_display[segment] = nominal[segment] * np.exp(np.maximum(high_gap, 0))
+        out[f"{metric}_lower_display"] = lo_display
+        out[f"{metric}_upper_display"] = hi_display
+    return out
+
+
+def lr_curve_ci_from_scores(
+    data: pd.DataFrame,
+    score_col: str = "predicted_risk",
+    label_col: str = "target",
+    *,
+    min_count: int = 10,
+    fpr_min: float = 0.005,
+    fpr_max: float = 0.95,
+    min_lrplus: float = 1.001,
+    confidence: float = 0.95,
+    n_boot: int = 3000,
+    random_state: int = 1769,
+    chunk_size: int = 48,
+    smooth_sigma: float = 0.0,
+) -> pd.DataFrame:
+    """Return pointwise LR+/LR- bootstrap CIs along a non-dominated frontier.
+
+    TP* and FP* are independently drawn from Binomial(n_pos, empirical TPR)
+    and Binomial(n_neg, empirical FPR), respectively, AT EACH FIXED THRESHOLD;
+    the same simulated TP*/FP* are used for both likelihood ratios. Thus the
+    columns give marginal, pointwise CIs. They are not joint CIs, simultaneous
+    curve bands, or valid post-selection coverage guarantees for the frontier.
+
+    The returned nominal curve is sorted by LR- and restricted to non-dominated
+    operating points with all four confusion-matrix cells >= min_count.
+    Both raw *_lower/*_upper and optional smoothed *_display columns are
+    returned. Smoothing is cosmetic: only RAW columns are inferential outputs.
+
+    Score direction: a larger score denotes greater positive-class risk.
+    """
+    if not 0 < float(fpr_min) < float(fpr_max) < 1:
+        raise ValueError("Require 0 < fpr_min < fpr_max < 1")
+    if not 0 < float(confidence) < 1:
+        raise ValueError("confidence must be strictly between 0 and 1")
+    if min_count < 1 or n_boot < 100 or chunk_size < 1 or smooth_sigma < 0:
+        raise ValueError("min_count>=1, n_boot>=100, chunk_size>=1, smooth_sigma>=0 required")
+
+    labels = pd.to_numeric(data[label_col], errors="coerce").to_numpy(dtype=float)
+    scores = pd.to_numeric(data[score_col], errors="coerce").to_numpy(dtype=float)
+    ok = np.isfinite(labels) & np.isfinite(scores) & np.isin(labels, (0, 1))
+    labels, scores = labels[ok], scores[ok]
+    positive_scores = np.sort(scores[labels == 1])
+    negative_scores = np.sort(scores[labels == 0])
+    n_pos, n_neg = len(positive_scores), len(negative_scores)
+    if min(n_pos, n_neg) < 2 * min_count:
+        raise ValueError(f"Too few positives or negatives: n_pos={n_pos}, n_neg={n_neg}")
+
+    lo_fpr = max(float(fpr_min), 1 / n_neg)
+    if lo_fpr >= fpr_max:
+        raise ValueError("No FPR search range supports the specified sample size")
+    knee = min(max(0.10, lo_fpr), fpr_max)
+    levels = np.unique(np.r_[np.geomspace(lo_fpr, knee, 90),
+                              np.linspace(knee, fpr_max, 170)])
+    idx = np.clip(np.floor((1 - levels) * (n_neg - 1)).astype(int), 0, n_neg - 1)
+    thresholds = np.unique(negative_scores[idx])[::-1]
+    tp = n_pos - np.searchsorted(positive_scores, thresholds, side="left")
+    fp = n_neg - np.searchsorted(negative_scores, thresholds, side="left")
+    fn, tn = n_pos - tp, n_neg - fp
+    tpr, fpr = tp / n_pos, fp / n_neg
+
+    valid = ((tp >= min_count) & (fp >= min_count) &
+             (fn >= min_count) & (tn >= min_count) &
+             (fpr >= fpr_min) & (fpr <= fpr_max))
+    with np.errstate(divide="ignore", invalid="ignore"):
+        lr_plus = tpr / fpr
+        lr_minus = (1 - tpr) / (1 - fpr)
+    valid &= (np.isfinite(lr_plus) & np.isfinite(lr_minus) &
+              (lr_plus > min_lrplus) & (lr_minus > 0) & (lr_minus < 1))
+    out = pd.DataFrame({
+        "LR-": lr_minus[valid], "LR+": lr_plus[valid],
+        "TP": tp[valid], "FP": fp[valid], "FN": fn[valid], "TN": tn[valid],
+        "TPR": tpr[valid], "FPR": fpr[valid], "threshold": thresholds[valid],
+    }).sort_values(["LR-", "LR+"], ascending=[True, False]).reset_index(drop=True)
+
+    if len(out):
+        values = out["LR+"].to_numpy(dtype=float)
+        prev = np.r_[-np.inf, np.maximum.accumulate(values)[:-1]]
+        out = out.loc[values > prev + 1e-10].reset_index(drop=True)
+
+    out["finite_bootstrap_fraction"] = np.nan
+    for column in _CI_COLS:
+        out[column] = np.nan
+
+    rng = np.random.default_rng(random_state)
+    qlow, qhigh = (1 - confidence) / 2, (1 + confidence) / 2
+    for start in range(0, len(out), chunk_size):
+        stop = min(start + chunk_size, len(out))
+        part = out.iloc[start:stop]
+        bs_tp = rng.binomial(n_pos, part["TPR"].to_numpy(), size=(n_boot, len(part)))
+        bs_fp = rng.binomial(n_neg, part["FPR"].to_numpy(), size=(n_boot, len(part)))
+        bs_fn, bs_tn = n_pos - bs_tp, n_neg - bs_fp
+        bootstrap_valid = (bs_tp > 0) & (bs_fp > 0) & (bs_fn > 0) & (bs_tn > 0)
+        finite_fraction = bootstrap_valid.mean(axis=0)
+        out.loc[start:stop-1, "finite_bootstrap_fraction"] = finite_fraction
+        columns_to_compute = np.flatnonzero(finite_fraction >= 0.98)
+        if not len(columns_to_compute):
+            continue
+        with np.errstate(divide="ignore", invalid="ignore"):
+            bs_plus = (bs_tp / n_pos) / (bs_fp / n_neg)
+            bs_minus = (bs_fn / n_pos) / (bs_tn / n_neg)
+        for metric, sample in (("LR+", bs_plus), ("LR-", bs_minus)):
+            s = sample[:, columns_to_compute].astype(float)
+            s[~bootstrap_valid[:, columns_to_compute]] = np.nan
+            lo, hi = np.nanquantile(s, [qlow, qhigh], axis=0)
+            index = np.arange(start, stop)[columns_to_compute]
+            nominal = out.loc[index, metric].to_numpy(dtype=float)
+            out.loc[index, f"{metric}_lower"] = np.minimum(lo, nominal)
+            out.loc[index, f"{metric}_upper"] = np.maximum(hi, nominal)
+
+    out = _smooth_lr_widths(out, sigma=float(smooth_sigma))
+    out.attrs.update(n_positive=n_pos, n_negative=n_neg,
+                     confidence=confidence, method="pointwise_binomial_bootstrap",
+                     frontier_selected=True, valid_bootstrap_min=0.98,
+                     display_smoothed=bool(smooth_sigma > 0),
+                     warning="Pointwise marginal CIs; no joint, simultaneous, or frontier post-selection coverage")
+    return out
+
+
+def plot_lr_ci_fill(ax, curve: pd.DataFrame, *, color: str, alpha: float = 0.2,
+                    use_display: bool = False, **kwargs):
+    """Draw an LR+ pointwise marginal CI fill against nominal LR- (no edges).
+
+    LR- uncertainty is available in the returned curve table but is not shown
+    in this vertical ribbon. This helper is visual, NOT a joint LR CI region.
+    """
+    suffix = "_display" if use_display else ""
+    x = curve["LR-"].to_numpy(dtype=float)
+    lo = curve[f"LR+_lower{suffix}"].to_numpy(dtype=float)
+    hi = curve[f"LR+_upper{suffix}"].to_numpy(dtype=float)
+    good = np.isfinite(x) & np.isfinite(lo) & np.isfinite(hi) & (lo <= hi)
+    return ax.fill_between(x, lo, hi, where=good, color=color,
+                           alpha=alpha, linewidth=0, interpolate=False, **kwargs)

zedstat-0.2.0/zedstat/pr_ci.py

@@ -0,0 +1,185 @@
+"""Score-level precision--recall curves and approximate fixed-threshold CIs.
+
+The PR curve is computed from actual score thresholds, never by regridding a
+ROC in FPR or by inserting the (recall=0, precision=1) plotting convention.
+Unsupported endpoints are omitted rather than imputed or extrapolated.
+
+The pointwise intervals use a log-ratio delta approximation. Their coverage
+is not simultaneous over the curve, does not account for threshold selection,
+and the optional smoothed display boundaries are purely graphical.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.ndimage import gaussian_filter1d
+from scipy.special import expit, logit
+from scipy.stats import norm
+
+
+_COLUMNS = ("threshold", "tpr", "fpr", "ppv", "TP", "FP", "FN", "TN", "flags",
+            "ppv_lower", "ppv_upper", "ppv_se_logit",
+            "ppv_lower_display", "ppv_upper_display")
+
+
+def precision_recall_ci_from_scores(
+    data,
+    *,
+    score_col="predicted_risk",
+    label_col="target",
+    prevalence=None,
+    prevalence_sample_size=None,
+    confidence=0.95,
+    min_tp=10,
+    min_fp=5,
+    min_flags=20,
+    max_points=1000,
+    display_sigma=0.0,
+):
+    """Return a supported PR curve with optional 95% pointwise PPV intervals.
+
+    Rates are computed from *observed score thresholds*.  ``prevalence`` is
+    the target/deployment prevalence; when omitted, the sample prevalence is
+    used, and its binomial estimation variance is included by default.
+
+    When a target prevalence is supplied, it is treated as fixed unless
+    ``prevalence_sample_size`` is provided. If target prevalence was estimated
+    from an independent representative cohort, provide its sample size to
+    include approximate prevalence uncertainty. For weights, clustering, or
+    dependent data, these simple iid delta-method intervals are insufficient.
+
+    The nominal PR curve starts at the first real threshold meeting the
+    minimum cell-count support. It never inserts the (0,1) plot convention.
+    For identical recalls the last threshold (largest FPR) is retained.
+
+    The raw CI limits are in ``ppv_lower`` and ``ppv_upper``; smoothed limits
+    are separate, and are not guaranteed 95% intervals. The supplied target
+    prevalence is not modified by smoothing or regularization.
+    """
+    if not (0 < float(confidence) < 1):
+        raise ValueError("confidence must lie in (0,1)")
+    if min_tp < 1 or min_fp < 1 or min_flags < 1:
+        raise ValueError("min_tp, min_fp, min_flags must all be >= 1")
+    if max_points is not None and int(max_points) < 2:
+        raise ValueError("max_points must be >= 2 or None")
+    if float(display_sigma) < 0:
+        raise ValueError("display_sigma must be nonnegative")
+
+    labels = pd.to_numeric(data[label_col], errors="coerce").to_numpy(dtype=float)
+    scores = pd.to_numeric(data[score_col], errors="coerce").to_numpy(dtype=float)
+    good = np.isfinite(labels) & np.isfinite(scores) & np.isin(labels, [0, 1])
+    labels = labels[good].astype(np.int8)
+    scores = scores[good]
+    n = len(labels)
+    n_pos = int(labels.sum())
+    n_neg = int(n - n_pos)
+    if not n_pos or not n_neg:
+        raise ValueError("At least one valid positive and negative label is required")
+
+    if prevalence is None:
+        pi = n_pos / n
+        prevalence_n = n if prevalence_sample_size is None else int(prevalence_sample_size)
+    else:
+        pi = float(prevalence)
+        prevalence_n = None if prevalence_sample_size is None else int(prevalence_sample_size)
+    if not 0 < pi < 1:
+        raise ValueError("prevalence must be in (0,1)")
+    if prevalence_n is not None and prevalence_n <= 0:
+        raise ValueError("prevalence_sample_size must be positive")
+
+    # Sort once and form confusion-matrix counts only at real, unique scores.
+    order = np.argsort(-scores, kind="stable")
+    sorted_scores = scores[order]
+    sorted_labels = labels[order]
+    last = np.flatnonzero(np.r_[sorted_scores[:-1] != sorted_scores[1:], True])
+    tp = np.cumsum(sorted_labels, dtype=np.int64)[last]
+    fp = (last + 1) - tp
+    fn = n_pos - tp
+    tn = n_neg - fp
+    flags = last + 1
+    tpr = tp / n_pos
+    fpr = fp / n_neg
+    denom = pi * tpr + (1 - pi) * fpr
+    with np.errstate(divide="ignore", invalid="ignore"):
+        ppv = pi * tpr / denom
+
+    # Suppress low-count regimes, not merely x=0.  Those operating points are
+    # precisely where the legacy ROC-grid origin produces spurious PRC spikes.
+    supported = ((tp >= min_tp) & (fp >= min_fp) & (flags >= min_flags) &
+                 np.isfinite(ppv) & (denom > 0))
+    df = pd.DataFrame({
+        "threshold": sorted_scores[last][supported],
+        "tpr": tpr[supported], "fpr": fpr[supported], "ppv": ppv[supported],
+        "TP": tp[supported], "FP": fp[supported],
+        "FN": fn[supported], "TN": tn[supported], "flags": flags[supported],
+    })
+
+    # A PRC is a graph against recall: a unique recall coordinate gives a
+    # non-self-intersecting polyline. The last empirical threshold at that
+    # recall is retained, never an interpolated or fictitious threshold.
+    df = df.drop_duplicates(subset="tpr", keep="last").reset_index(drop=True)
+    if max_points is not None and len(df) > int(max_points):
+        r = df["tpr"].to_numpy(dtype=float)
+        wanted = np.linspace(r[0], r[-1], int(max_points))
+        keep = np.unique(np.r_[0, np.searchsorted(r, wanted, side="left"), len(r)-1])
+        df = df.iloc[keep].reset_index(drop=True)
+
+    tp_v = df["TP"].to_numpy(dtype=float)
+    fp_v = df["FP"].to_numpy(dtype=float)
+    center = df["ppv"].to_numpy(dtype=float)
+    # Standard fixed-threshold delta variance on logit(PPV) = logit(pi) + log(LR+).
+    if len(df):
+        variance = (1.0 / tp_v - 1.0 / n_pos +
+                    1.0 / fp_v - 1.0 / n_neg)
+        if prevalence_n is not None:
+            variance += 1.0 / (prevalence_n * pi * (1 - pi))
+        se = np.sqrt(np.maximum(variance, 0))
+        z = norm.ppf(0.5 + float(confidence) / 2.0)
+        # With min counts, 0<PPV<1. Do not infer limits at degenerate points.
+        lo = expit(logit(center) - z * se)
+        hi = expit(logit(center) + z * se)
+        if display_sigma > 0 and len(df) > 2:
+            # Display-only: smooth uncertainty widths, NEVER nominal precision.
+            dlo = np.maximum(logit(center) - logit(lo), 0.0)
+            dhi = np.maximum(logit(hi) - logit(center), 0.0)
+            dlo = gaussian_filter1d(dlo, float(display_sigma), mode="nearest")
+            dhi = gaussian_filter1d(dhi, float(display_sigma), mode="nearest")
+            lo_display = expit(logit(center) - dlo)
+            hi_display = expit(logit(center) + dhi)
+        else:
+            lo_display, hi_display = lo.copy(), hi.copy()
+    else:
+        se = lo = hi = lo_display = hi_display = np.empty(0, dtype=float)
+    df["ppv_lower"] = lo
+    df["ppv_upper"] = hi
+    df["ppv_se_logit"] = se
+    df["ppv_lower_display"] = lo_display
+    df["ppv_upper_display"] = hi_display
+    df = df.loc[:, _COLUMNS]
+    df.attrs["precision_recall_ci"] = {
+        "confidence": float(confidence),
+        "method": "score_level_fixed_threshold_log_ratio_delta",
+        "prevalence": pi,
+        "prevalence_sample_size": prevalence_n,
+        "sample_n_pos": n_pos,
+        "sample_n_neg": n_neg,
+        "min_tp": min_tp, "min_fp": min_fp, "min_flags": min_flags,
+        "display_sigma": display_sigma,
+        "warning": "Pointwise approximate intervals only; not simultaneous or threshold-selection adjusted."
+    }
+    return df
+
+
+def plot_precision_recall_ci_fill(ax, curve, *, color=None, alpha=0.2,
+                                  use_display=False, zorder=1, **kwargs):
+    """Plot only finite score-level CI support; never invent endpoint values."""
+    suffix = "_display" if use_display else ""
+    x = curve["tpr"].to_numpy(dtype=float)
+    y = curve["ppv"].to_numpy(dtype=float)
+    lo = curve[f"ppv_lower{suffix}"].to_numpy(dtype=float)
+    hi = curve[f"ppv_upper{suffix}"].to_numpy(dtype=float)
+    ok = (np.isfinite(x) & np.isfinite(y) & np.isfinite(lo) & np.isfinite(hi)
+          & (lo <= y) & (y <= hi))
+    return ax.fill_between(x, lo, hi, where=ok, color=color, alpha=alpha,
+                           linewidth=0, interpolate=False, zorder=zorder, **kwargs)

{zedstat-0.0.153 → zedstat-0.2.0}/zedstat/zedstat.py

@@ -1918,3 +1918,14 @@ try:
     __all__.append('lr_nondominated_frontier')
 except Exception:
     pass
+
+# Raw-score-based, pointwise LR confidence intervals; separate from the
+# historical analytic getBounds() API and its ROC interpolation.
+from .lr_ci import lr_curve_ci_from_scores, plot_lr_ci_fill
+try:
+    __all__.extend(('lr_curve_ci_from_scores', 'plot_lr_ci_fill'))
+except Exception:
+    pass
+
+# Score-based CI extensions (pointwise; display smoothing is non-inferential)
+from .pr_ci import precision_recall_ci_from_scores, plot_precision_recall_ci_fill

{zedstat-0.0.153 → zedstat-0.2.0/zedstat.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: zedstat
-Version: 0.0.153
+Version: 0.2.0
 Summary: Statistics tools for ML models and deployment
 Home-page: https://github.com/zeroknowledgediscovery/zedstat
-Download-URL: https://github.com/zeroknowledgediscovery/zedstat/archive/0.0.153.tar.gz
+Download-URL: https://github.com/zeroknowledgediscovery/zedstat/archive/0.2.0.tar.gz
 Author: zed.uchicago.edu
 Author-email: ishanu@uchicago.edu
 License: LICENSE

{zedstat-0.0.153 → zedstat-0.2.0}/zedstat.egg-info/SOURCES.txt

@@ -3,11 +3,18 @@ MANIFEST.in
 README.rst
 setup.py
 version.py
+tests/test_ci_logratio.py
+tests/test_getbounds_current_geometry.py
+tests/test_getbounds_preserves_nominal.py
+tests/test_lr_ci.py
 zedstat/__init__.py
 zedstat/calibration.py
 zedstat/ci.py
+zedstat/ci_logratio.py
 zedstat/example_combine.py
+zedstat/lr_ci.py
 zedstat/mwauc.py
+zedstat/pr_ci.py
 zedstat/rrci.py
 zedstat/textable.py
 zedstat/zcombine.py

zedstat-0.0.153/version.py

@@ -1 +0,0 @@
-__version__ = '0.0.153'

zedstat-0.0.153/zedstat/__init__.py

@@ -1,18 +0,0 @@
-"""                                                                                                                        
-# zedstat                                                                                                                   
-                                                                                                                           
-Description:                                                                                                               
-    Utilities for uncertainty quantification and deployment of ML models                                                                  
-                                                                                                                           
----                                                                                                                        
-                                                                                                                           
-Installation:                                                                                                              
-   ```                                                                                                                     
-      pip install zedstat                                                                                                   
-   ```                                                                                                                                                                                                      
-Notes:                                                                                                                     
-   Useful for calculation of likelihood ratios, confidence intervals on AUC,
-   simple performance interpretation (list to be expanded)
-
-
-"""