invarlock 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

invarlock/reporting/certificate_schema.py

@@ -29,6 +29,7 @@ CERTIFICATE_JSON_SCHEMA: dict[str, Any] = {
         "plugins",
         "meta",
         "dataset",
+        "primary_metric",
     ],
     "properties": {
         "schema_version": {"const": CERTIFICATE_SCHEMA_VERSION},
@@ -64,11 +65,12 @@ CERTIFICATE_JSON_SCHEMA: dict[str, Any] = {
                 "seq_len": {"type": "integer", "minimum": 1},
                 "windows": {
                     "type": "object",
-                    "required": ["preview", "final"],
+                    "required": ["preview", "final", "stats"],
                     "properties": {
                         "preview": {"type": "integer", "minimum": 0},
                         "final": {"type": "integer", "minimum": 0},
                         "seed": {"type": "integer"},
+                        "stats": {"type": "object"},
                     },
                 },
             },
@@ -77,6 +79,7 @@ CERTIFICATE_JSON_SCHEMA: dict[str, Any] = {
         # ppl_* block removed from required schema; may appear for ppl-like tasks but is optional
         "primary_metric": {
             "type": "object",
+            "required": ["kind"],
             "properties": {
                 "kind": {"type": "string"},
                 "unit": {"type": "string"},

invarlock/reporting/guards_analysis.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import math
 from typing import Any, no_type_check
 
-from invarlock.core.auto_tuning import TIER_POLICIES
+from invarlock.core.auto_tuning import get_tier_policies
 
 from .policy_utils import _promote_legacy_multiple_testing_key, _resolve_policy_tier
 from .report_types import RunReport
@@ -133,7 +133,8 @@ def _extract_spectral_analysis(
     report: RunReport, baseline: dict[str, Any]
 ) -> dict[str, Any]:
     tier = _resolve_policy_tier(report)
-    tier_defaults = TIER_POLICIES.get(tier, TIER_POLICIES.get("balanced", {}))
+    tier_policies = get_tier_policies()
+    tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
     spectral_defaults = tier_defaults.get("spectral", {}) if tier_defaults else {}
     default_sigma_quantile = spectral_defaults.get("sigma_quantile", 0.95)
     default_deadband = spectral_defaults.get("deadband", 0.1)
@@ -166,9 +167,15 @@ def _extract_spectral_analysis(
     caps_exceeded = (
         bool(guard_metrics.get("caps_exceeded", False)) if guard_metrics else False
     )
-    max_caps = guard_policy.get("max_caps") if guard_policy else None
+    max_caps = guard_metrics.get("max_caps") if guard_metrics else None
+    if max_caps is None and guard_policy:
+        max_caps = guard_policy.get("max_caps")
     if max_caps is None:
         max_caps = default_max_caps
+    try:
+        max_caps = int(max_caps)
+    except Exception:
+        max_caps = int(default_max_caps)
 
     try:
         max_spectral_norm = float(
@@ -618,10 +625,15 @@ def _extract_rmt_analysis(
     report: RunReport, baseline: dict[str, Any]
 ) -> dict[str, Any]:
     tier = _resolve_policy_tier(report)
-    tier_defaults = TIER_POLICIES.get(tier, TIER_POLICIES.get("balanced", {}))
+    tier_policies = get_tier_policies()
+    tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
     default_epsilon_map = (
-        tier_defaults.get("rmt", {}).get("epsilon", {}) if tier_defaults else {}
+        tier_defaults.get("rmt", {}).get("epsilon_by_family")
+        if isinstance(tier_defaults, dict)
+        else {}
     )
+    if not default_epsilon_map and isinstance(tier_defaults, dict):
+        default_epsilon_map = (tier_defaults.get("rmt", {}) or {}).get("epsilon", {})
     default_epsilon_map = {
         str(family): float(value)
         for family, value in (default_epsilon_map or {}).items()
@@ -631,6 +643,16 @@ def _extract_rmt_analysis(
     outliers_guarded = 0
     outliers_bare = 0
     epsilon_default = 0.1
+    try:
+        eps_def = (
+            tier_defaults.get("rmt", {}).get("epsilon_default")
+            if isinstance(tier_defaults, dict)
+            else None
+        )
+        if isinstance(eps_def, int | float) and math.isfinite(float(eps_def)):
+            epsilon_default = float(eps_def)
+    except Exception:
+        pass
     stable = True
     explicit_stability = False
     max_ratio = 0.0
@@ -640,19 +662,54 @@ def _extract_rmt_analysis(
     baseline_outliers_per_family: dict[str, int] = {}
     outliers_per_family: dict[str, int] = {}
     epsilon_violations: list[Any] = []
+    margin_used = None
+    deadband_used = None
+    policy_out: dict[str, Any] | None = None
 
     for guard in report.get("guards", []) or []:
         if str(guard.get("name", "")).lower() == "rmt":
             guard_metrics = guard.get("metrics", {}) or {}
             guard_policy = guard.get("policy", {}) or {}
+            if isinstance(guard_policy, dict) and guard_policy:
+                policy_out = dict(guard_policy)
+                if "epsilon_by_family" not in policy_out and isinstance(
+                    policy_out.get("epsilon"), dict
+                ):
+                    policy_out["epsilon_by_family"] = dict(policy_out["epsilon"])
+                if isinstance(policy_out.get("margin"), int | float) and math.isfinite(
+                    float(policy_out.get("margin"))
+                ):
+                    margin_used = float(policy_out.get("margin"))
+                if isinstance(
+                    policy_out.get("deadband"), int | float
+                ) and math.isfinite(float(policy_out.get("deadband"))):
+                    deadband_used = float(policy_out.get("deadband"))
+                if isinstance(
+                    policy_out.get("epsilon_default"), int | float
+                ) and math.isfinite(float(policy_out.get("epsilon_default"))):
+                    epsilon_default = float(policy_out.get("epsilon_default"))
+            if isinstance(
+                guard_metrics.get("epsilon_default"), int | float
+            ) and math.isfinite(float(guard_metrics.get("epsilon_default"))):
+                epsilon_default = float(guard_metrics.get("epsilon_default"))
             outliers_guarded = guard_metrics.get(
                 "rmt_outliers", guard_metrics.get("layers_flagged", outliers_guarded)
             )
             max_ratio = guard_metrics.get("max_ratio", 0.0)
-            epsilon_default = guard_policy.get(
-                "deadband", guard_metrics.get("deadband_used", epsilon_default)
-            )
             epsilon_map = guard_metrics.get("epsilon_by_family", {}) or epsilon_map
+            if not epsilon_map and isinstance(guard_policy, dict):
+                eps_src = guard_policy.get("epsilon_by_family") or guard_policy.get(
+                    "epsilon"
+                )
+                if isinstance(eps_src, dict):
+                    try:
+                        epsilon_map = {
+                            str(k): float(v)
+                            for k, v in eps_src.items()
+                            if isinstance(v, int | float) and math.isfinite(float(v))
+                        }
+                    except Exception:
+                        pass
             baseline_outliers_per_family = (
                 guard_metrics.get("baseline_outliers_per_family", {})
                 or baseline_outliers_per_family
@@ -844,7 +901,7 @@ def _extract_rmt_analysis(
     }
     delta_per_family = {str(k): _to_int(v) for k, v in delta_per_family.items()}
 
-    return {
+    result = {
         "outliers_bare": outliers_bare,
         "outliers_guarded": outliers_guarded,
         "epsilon": epsilon_scalar,
@@ -862,6 +919,13 @@ def _extract_rmt_analysis(
         "mean_deviation_ratio": mean_deviation_ratio,
         "families": family_breakdown,
     }
+    if margin_used is not None:
+        result["margin"] = float(margin_used)
+    if deadband_used is not None:
+        result["deadband"] = float(deadband_used)
+    if policy_out:
+        result["policy"] = policy_out
+    return result
 
 
 @no_type_check
@@ -873,10 +937,14 @@ def _extract_variance_analysis(report: RunReport) -> dict[str, Any]:
     ratio_ci = None
     calibration = {}
     guard_metrics: dict[str, Any] = {}
+    guard_policy: dict[str, Any] | None = None
     for guard in report.get("guards", []) or []:
         if "variance" in str(guard.get("name", "")).lower():
             metrics = guard.get("metrics", {}) or {}
             guard_metrics = metrics
+            gp = guard.get("policy", {}) or {}
+            if isinstance(gp, dict) and gp:
+                guard_policy = dict(gp)
             ve_enabled = metrics.get("ve_enabled", bool(metrics))
             gain = metrics.get("ab_gain", metrics.get("gain", None))
             ppl_no_ve = metrics.get("ppl_no_ve", None)
@@ -932,11 +1000,41 @@ def _extract_variance_analysis(report: RunReport) -> dict[str, Any]:
     if guard_metrics.get("ab_windows_used") is not None:
         ab_section["windows_used"] = guard_metrics["ab_windows_used"]
     if guard_metrics.get("ab_provenance"):
-        ab_section["provenance"] = guard_metrics["ab_provenance"]
+        prov = guard_metrics["ab_provenance"]
+        if isinstance(prov, dict):
+            prov_out = dict(prov)
+
+            # Normalize a top-level `window_ids` list for docs + auditability.
+            if "window_ids" not in prov_out:
+                window_ids: set[int] = set()
+
+                def _collect(node: Any) -> None:
+                    if isinstance(node, dict):
+                        ids = node.get("window_ids")
+                        if isinstance(ids, list):
+                            for wid in ids:
+                                if isinstance(wid, int | float):
+                                    window_ids.add(int(wid))
+                        for v in node.values():
+                            _collect(v)
+                        return
+                    if isinstance(node, list):
+                        for v in node:
+                            _collect(v)
+
+                _collect(prov_out)
+                if window_ids:
+                    prov_out["window_ids"] = sorted(window_ids)
+
+            ab_section["provenance"] = prov_out
+        else:
+            ab_section["provenance"] = prov
     if guard_metrics.get("ab_point_estimates"):
         ab_section["point_estimates"] = guard_metrics["ab_point_estimates"]
     if ab_section:
         result["ab_test"] = ab_section
+    if guard_policy:
+        result["policy"] = guard_policy
     return result
 
 

invarlock/reporting/normalizer.py

@@ -40,15 +40,34 @@ def normalize_run_report(report: Mapping[str, Any] | RunReport) -> RunReport:
     # ---- meta ----
     meta_in = _as_mapping(src.get("meta"))
     ts = _str(meta_in.get("ts") or datetime.now().isoformat())
+    try:
+        seed_value = int(meta_in.get("seed", 42))
+    except Exception:
+        seed_value = 42
     meta_dict: dict[str, Any] = {
         "model_id": _str(meta_in.get("model_id")),
         "adapter": _str(meta_in.get("adapter")),
         "commit": _str(meta_in.get("commit")),
-        "seed": int(meta_in.get("seed", 42) or 42),
+        "seed": seed_value,
         "device": _str(meta_in.get("device", "cpu")),
         "ts": ts,
         "auto": meta_in.get("auto") if isinstance(meta_in.get("auto"), dict) else None,
     }
+    # Preserve additional provenance knobs used by certificate/digests.
+    for key in (
+        "policy_overrides",
+        "overrides",
+        "plugins",
+        "config",
+        "seeds",
+        "determinism",
+        "env_flags",
+        "cuda_flags",
+        "tokenizer_hash",
+        "model_profile",
+    ):
+        if key in meta_in:
+            meta_dict[key] = meta_in.get(key)
     meta = cast(MetaData, meta_dict)
 
     # ---- data ----
@@ -164,6 +183,7 @@ def normalize_run_report(report: Mapping[str, Any] | RunReport) -> RunReport:
         "spectral",
         "rmt",
         "invariants",
+        "logloss_delta_ci",
         "bootstrap",
         "reduction",
         "moe",
@@ -174,6 +194,9 @@ def normalize_run_report(report: Mapping[str, Any] | RunReport) -> RunReport:
         "window_pairing_reason",
         "window_pairing_preview",
         "window_pairing_final",
+        "window_plan",
+        "window_capacity",
+        "stats",
         "total_tokens",
         "preview_total_tokens",
         "final_total_tokens",

invarlock/reporting/policy_utils.py

@@ -6,7 +6,7 @@ import hashlib
 import json
 from typing import Any
 
-from invarlock.core.auto_tuning import TIER_POLICIES
+from invarlock.core.auto_tuning import get_tier_policies, resolve_tier_policies
 
 from .report_types import RunReport
 
@@ -38,17 +38,40 @@ def _compute_thresholds_payload(
     from .certificate import TIER_RATIO_LIMITS  # local to avoid cycles
 
     tier_lc = (tier or "balanced").lower()
-    ratio_limit_base = float(TIER_RATIO_LIMITS.get(tier_lc, 1.10))
-    tier_policy = TIER_POLICIES.get(tier_lc, {}) if isinstance(tier_lc, str) else {}
     metrics_policy = (
-        tier_policy.get("metrics", {}) if isinstance(tier_policy, dict) else {}
-    )
-    pm_policy = (
-        metrics_policy.get("pm_ratio", {}) if isinstance(metrics_policy, dict) else {}
-    )
-    acc_policy = (
-        metrics_policy.get("accuracy", {}) if isinstance(metrics_policy, dict) else {}
+        resolved_policy.get("metrics", {}) if isinstance(resolved_policy, dict) else {}
     )
+    if not isinstance(metrics_policy, dict):
+        metrics_policy = {}
+
+    pm_policy = metrics_policy.get("pm_ratio", {})
+    if not isinstance(pm_policy, dict):
+        pm_policy = {}
+
+    acc_policy = metrics_policy.get("accuracy", {})
+    if not isinstance(acc_policy, dict):
+        acc_policy = {}
+
+    ratio_limit_base = pm_policy.get("ratio_limit_base")
+    try:
+        if ratio_limit_base is not None:
+            ratio_limit_base = float(ratio_limit_base)
+    except Exception:
+        ratio_limit_base = None
+    if ratio_limit_base is None:
+        tier_defaults = get_tier_policies().get(tier_lc, {})
+        fallback_pm = (
+            (tier_defaults.get("metrics") or {}).get("pm_ratio")
+            if isinstance(tier_defaults, dict)
+            else {}
+        )
+        ratio_limit_base = float(
+            (fallback_pm or {}).get(
+                "ratio_limit_base", TIER_RATIO_LIMITS.get(tier_lc, 1.10)
+            )
+            if isinstance(fallback_pm, dict)
+            else TIER_RATIO_LIMITS.get(tier_lc, 1.10)
+        )
     variance_policy = (
         resolved_policy.get("variance", {}) if isinstance(resolved_policy, dict) else {}
     )
@@ -154,11 +177,21 @@ def _format_epsilon_map(epsilon_map: Any) -> dict[str, float]:
 
 
 def _build_resolved_policies(
-    tier: str, spectral: dict[str, Any], rmt: dict[str, Any], variance: dict[str, Any]
+    tier: str,
+    spectral: dict[str, Any],
+    rmt: dict[str, Any],
+    variance: dict[str, Any],
+    *,
+    profile: str | None = None,
+    explicit_overrides: dict[str, dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     """Merge tier defaults with observed policies to surface the resolved configuration."""
     tier_key = (tier or "balanced").lower()
-    base = copy.deepcopy(TIER_POLICIES.get(tier_key, TIER_POLICIES.get("balanced", {})))
+    if tier_key == "none":
+        tier_key = "balanced"
+    base = resolve_tier_policies(
+        tier_key, edit_name=None, explicit_overrides=explicit_overrides, profile=profile
+    )
 
     resolved: dict[str, Any] = {}
 
@@ -280,6 +313,37 @@ def _build_resolved_policies(
     variance_resolved: dict[str, Any] = {}
     if isinstance(base_variance, dict):
         variance_resolved.update(base_variance)
+
+    observed_variance_policy = (
+        variance.get("policy") if isinstance(variance, dict) else None
+    )
+    if isinstance(observed_variance_policy, dict) and observed_variance_policy:
+        for key in (
+            "deadband",
+            "min_abs_adjust",
+            "max_scale_step",
+            "min_effect_lognll",
+            "predictive_one_sided",
+            "topk_backstop",
+            "max_adjusted_modules",
+            "tap",
+            "predictive_gate",
+            "scope",
+            "clamp",
+            "min_gain",
+            "min_rel_gain",
+            "max_calib",
+            "seed",
+            "mode",
+            "alpha",
+            "tie_breaker_deadband",
+            "calibration",
+        ):
+            if (
+                key in observed_variance_policy
+                and observed_variance_policy.get(key) is not None
+            ):
+                variance_resolved[key] = observed_variance_policy.get(key)
     predictive_gate = variance.get("predictive_gate", {})
     predictive_one_sided = variance_resolved.get("predictive_one_sided")
     if isinstance(predictive_gate, dict) and "sided" in predictive_gate:
@@ -290,6 +354,10 @@ def _build_resolved_policies(
     variance_resolved["min_effect_lognll"] = _safe_float(
         variance_resolved.get("min_effect_lognll", 0.0), 0.0
     )
+    if "topk_backstop" in variance_resolved:
+        variance_resolved["topk_backstop"] = _safe_int(
+            variance_resolved.get("topk_backstop", 0), 0
+        )
     variance_resolved["max_adjusted_modules"] = _safe_int(
         variance_resolved.get("max_adjusted_modules", 0), 0
     )
@@ -307,10 +375,24 @@ def _build_resolved_policies(
         )
     resolved["variance"] = variance_resolved
 
-    # Confidence thresholds (optional policy knobs)
+    # Metric gates (PM ratio, accuracy, confidence, etc.)
     try:
         metrics = base.get("metrics", {}) if isinstance(base, dict) else {}
-        conf = metrics.get("confidence") if isinstance(metrics, dict) else None
+        if isinstance(metrics, dict) and metrics:
+            resolved["metrics"] = copy.deepcopy(metrics)
+    except Exception:
+        pass
+
+    # Confidence thresholds (optional policy knobs)
+    try:
+        conf = None
+        metrics = (
+            resolved.get("metrics")
+            if isinstance(resolved.get("metrics"), dict)
+            else None
+        )
+        if isinstance(metrics, dict):
+            conf = metrics.get("confidence")
         if isinstance(conf, dict) and conf:
             resolved["confidence"] = {}
             if "ppl_ratio_width_max" in conf:
@@ -428,7 +510,7 @@ def _extract_effective_policies(report: RunReport) -> dict[str, Any]:
                         guard_policy[key] = original_policy[key]
             policies[guard_name] = dict(guard_policy)
 
-    tier_defaults = TIER_POLICIES.get(_resolve_policy_tier(report), {})
+    tier_defaults = get_tier_policies().get(_resolve_policy_tier(report), {})
 
     def _merge_defaults(target: dict[str, Any], defaults: dict[str, Any]) -> None:
         for key, value in defaults.items():

invarlock/reporting/primary_metric_utils.py

@@ -102,6 +102,23 @@ def attach_primary_metric(
                     and float(base_final) > 0
                 ):
                     pm_copy["ratio_vs_baseline"] = float(fin) / float(base_final)
+                # Ensure display_ci aligns with log-space CI for ppl-like metrics
+                try:
+                    kind = str(pm_copy.get("kind", "")).lower()
+                except Exception:
+                    kind = ""
+                ci = pm_copy.get("ci")
+                if (
+                    kind.startswith("ppl")
+                    and isinstance(ci, list | tuple)
+                    and len(ci) == 2
+                ):
+                    try:
+                        lo, hi = float(ci[0]), float(ci[1])
+                        if math.isfinite(lo) and math.isfinite(hi):
+                            pm_copy["display_ci"] = [math.exp(lo), math.exp(hi)]
+                    except Exception:
+                        pass
                 # Provide a degenerate display CI if missing
                 if not isinstance(
                     pm_copy.get("display_ci"), list | tuple

invarlock/reporting/validate.py

@@ -407,25 +407,25 @@ def validate_guard_overhead(
             else None
         )
 
-        bare_final = None
-        guarded_final = None
+        bare_ppl = None
+        guarded_ppl = None
         if isinstance(bare_pm, dict):
-            bare_final = bare_pm.get("final")
+            bare_ppl = bare_pm.get("final")
         if isinstance(guarded_pm, dict):
-            guarded_final = guarded_pm.get("final")
+            guarded_ppl = guarded_pm.get("final")
 
         if (
-            isinstance(bare_final, (int | float))
-            and bare_final > 0
-            and isinstance(guarded_final, (int | float))
+            isinstance(bare_ppl, (int | float))
+            and bare_ppl > 0
+            and isinstance(guarded_ppl, (int | float))
         ):
-            overhead_ratio = float(guarded_final) / float(bare_final)
+            overhead_ratio = float(guarded_ppl) / float(bare_ppl)
             overhead_percent = (overhead_ratio - 1.0) * 100
 
             metrics["overhead_ratio"] = overhead_ratio
             metrics["overhead_percent"] = overhead_percent
-            metrics["bare_final"] = float(bare_final)
-            metrics["guarded_final"] = float(guarded_final)
+            metrics["bare_ppl"] = float(bare_ppl)
+            metrics["guarded_ppl"] = float(guarded_ppl)
 
             # Apply overhead gate
             checks["guard_overhead"] = overhead_ratio <= (1.0 + overhead_threshold)

{invarlock-0.3.1.dist-info → invarlock-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invarlock
-Version: 0.3.1
+Version: 0.3.3
 Summary: Edit‑agnostic robustness certificates for weight edits (InvarLock framework)
 Author-email: InvarLock Team <oss@invarlock.dev>
 Maintainer-email: InvarLock Maintainers <support@invarlock.dev>
@@ -112,7 +112,7 @@ they don’t, roll back safely.
 Technical: edit‑agnostic guard pipeline (invariants → spectral → RMT →
 variance) producing a machine‑readable Safety Certificate.
 
-> **Status:** 0.3.1 (pre‑1.0). Until 1.0, **minor** releases may be
+> **Status:** 0.3.3 (pre‑1.0). Until 1.0, **minor** releases may be
 > breaking. See CLI help and the CHANGELOG for updates.
 
 [![CI](https://img.shields.io/github/actions/workflow/status/invarlock/invarlock/ci.yml?branch=main&logo=github&label=CI)](https://github.com/invarlock/invarlock/actions/workflows/ci.yml)
@@ -289,14 +289,16 @@ pip install "invarlock[hf]"
 
 ## 💻 Support Matrix
 
-| Platform               | Status          | Notes                                      |
-| ---------------------- | --------------- | ------------------------------------------ |
-| Python 3.12+           | ✅ Required      |                                            |
-| Linux                  | ✅ Full          | Primary dev target                         |
-| macOS (Intel/M-series) | ✅ Full          | MPS supported (default on Apple Silicon)   |
-| Windows                | ❌ Not supported | Use WSL2 or a Linux container if required  |
-| CUDA                   | ✅ Recommended   | For larger models                          |
-| CPU                    | ✅ Fallback      | Slower but functional                      |
+<!-- markdownlint-disable MD060 -->
+| Platform               | Status          | Notes                                     |
+| ---------------------- | --------------- | ----------------------------------------- |
+| Python 3.12+           | ✅ Required      |                                           |
+| Linux                  | ✅ Full          | Primary dev target                        |
+| macOS (Intel/M-series) | ✅ Full          | MPS supported (default on Apple Silicon)  |
+| Windows                | ❌ Not supported | Use WSL2 or a Linux container if required |
+| CUDA                   | ✅ Recommended   | For larger models                         |
+| CPU                    | ✅ Fallback      | Slower but functional                     |
+<!-- markdownlint-enable MD060 -->
 
 **Device selection:** CUDA → MPS → CPU (auto). Override with torch env if
 needed (e.g., `CUDA_VISIBLE_DEVICES`).