invarlock 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

invarlock/guards/tier_config.py

@@ -31,7 +31,7 @@ _FALLBACK_CONFIG: dict[str, dict[str, Any]] = {
             "deadband": 0.02,
             "min_abs_adjust": 0.012,
             "max_scale_step": 0.03,
-            "min_effect_lognll": 0.0009,
+            "min_effect_lognll": 0.0,
             "predictive_one_sided": True,
             "topk_backstop": 1,
             "max_adjusted_modules": 1,
@@ -43,10 +43,10 @@ _FALLBACK_CONFIG: dict[str, dict[str, Any]] = {
             "max_caps": 5,
             "max_spectral_norm": None,
             "family_caps": {
-                "ffn": 2.5,
-                "attn": 2.8,
-                "embed": 3.0,
-                "other": 3.0,
+                "ffn": 3.849,
+                "attn": 3.018,
+                "embed": 1.05,
+                "other": 0.0,
             },
             "multiple_testing": {
                 "method": "bh",
@@ -57,12 +57,12 @@ _FALLBACK_CONFIG: dict[str, dict[str, Any]] = {
         "rmt_guard": {
             "deadband": 0.10,
             "margin": 1.5,
-            "epsilon_default": 0.10,
+            "epsilon_default": 0.01,
             "epsilon_by_family": {
-                "ffn": 0.10,
-                "attn": 0.08,
-                "embed": 0.12,
-                "other": 0.12,
+                "ffn": 0.01,
+                "attn": 0.01,
+                "embed": 0.01,
+                "other": 0.01,
             },
         },
     },
@@ -71,7 +71,7 @@ _FALLBACK_CONFIG: dict[str, dict[str, Any]] = {
             "deadband": 0.03,
             "min_abs_adjust": 0.02,
             "max_scale_step": 0.015,
-            "min_effect_lognll": 0.0018,
+            "min_effect_lognll": 0.016,
             "predictive_one_sided": False,
             "topk_backstop": 0,
             "max_adjusted_modules": 0,
@@ -81,61 +81,63 @@ _FALLBACK_CONFIG: dict[str, dict[str, Any]] = {
             "deadband": 0.05,
             "scope": "ffn",
             "max_caps": 3,
+            "max_spectral_norm": None,
             "family_caps": {
-                "ffn": 2.3,
+                "ffn": 3.849,
                 "attn": 2.6,
                 "embed": 2.8,
                 "other": 2.8,
             },
             "multiple_testing": {
                 "method": "bonferroni",
-                "alpha": 0.02,
+                "alpha": 0.000625,
                 "m": 4,
             },
         },
         "rmt_guard": {
             "deadband": 0.05,
             "margin": 1.3,
-            "epsilon_default": 0.06,
+            "epsilon_default": 0.01,
             "epsilon_by_family": {
-                "ffn": 0.06,
-                "attn": 0.05,
-                "embed": 0.07,
-                "other": 0.07,
+                "ffn": 0.01,
+                "attn": 0.01,
+                "embed": 0.01,
+                "other": 0.01,
             },
         },
     },
     "aggressive": {
         "variance_guard": {
             "deadband": 0.12,
-            "min_effect_lognll": 0.0005,
+            "min_effect_lognll": 0.033,
         },
         "spectral_guard": {
             "sigma_quantile": 0.98,
             "deadband": 0.15,
-            "scope": "all",
+            "scope": "ffn",
             "max_caps": 8,
+            "max_spectral_norm": None,
             "family_caps": {
-                "ffn": 3.0,
-                "attn": 3.2,
-                "embed": 3.5,
+                "ffn": 3.849,
+                "attn": 3.5,
+                "embed": 2.5,
                 "other": 3.5,
             },
             "multiple_testing": {
                 "method": "bh",
-                "alpha": 0.1,
+                "alpha": 0.00078125,
                 "m": 4,
             },
         },
         "rmt_guard": {
             "deadband": 0.15,
             "margin": 1.8,
-            "epsilon_default": 0.15,
+            "epsilon_default": 0.01,
             "epsilon_by_family": {
-                "ffn": 0.15,
-                "attn": 0.15,
-                "embed": 0.15,
-                "other": 0.15,
+                "ffn": 0.01,
+                "attn": 0.01,
+                "embed": 0.01,
+                "other": 0.01,
             },
         },
     },
@@ -257,7 +259,7 @@ def get_rmt_epsilon(tier: TierName = "balanced") -> dict[str, float]:
 def get_variance_min_effect(tier: TierName = "balanced") -> float:
     """Get VE min_effect_lognll for a tier."""
     config = get_tier_guard_config(tier, "variance_guard")
-    return config.get("min_effect_lognll", 0.0009)
+    return config.get("min_effect_lognll", 0.0)
 
 
 def check_drift(

invarlock/guards/variance.py

@@ -36,7 +36,7 @@ from ._contracts import guard_assert
 # Import the policy type and Guard interface
 from .policies import VariancePolicyDict
 
-__all__ = ["equalise_residual_variance", "equalise_branch_variance", "VarianceGuard"]
+__all__ = ["equalise_residual_variance", "VarianceGuard"]
 
 
 def _safe_mean(
@@ -348,33 +348,6 @@ def equalise_residual_variance(
     return applied_scales
 
 
-def equalise_branch_variance(
-    model: nn.Module,
-    dataloader,
-    windows: int = 32,
-    tol: float = 0.02,
-    scale_bias: bool = True,
-    seed: int = 42,
-    device: str | None = None,
-    allow_empty: bool = False,
-) -> dict[str, float]:
-    """
-    Legacy alias for equalise_residual_variance.
-
-    Maintained for backward compatibility.
-    """
-    return equalise_residual_variance(
-        model=model,
-        dataloader=dataloader,
-        windows=windows,
-        tol=tol,
-        scale_bias=scale_bias,
-        seed=seed,
-        device=device,
-        allow_empty=allow_empty,
-    )
-
-
 def _predictive_gate_outcome(
     mean_delta: float,
     delta_ci: tuple[float, float] | None,
@@ -1328,7 +1301,10 @@ class VarianceGuard(Guard):
             if not filtered_scales and topk > 0 and best_candidate:
                 name, scale = best_candidate
                 deadband = float(self._policy.get("deadband", 0.0) or 0.0)
-                threshold = max(deadband * 0.5, min_abs)
+                # Backstop should remain below the main min_abs filter; clamp if deadband is large.
+                threshold = max(deadband * 0.5, min_abs * 0.5)
+                if min_abs > 0 and threshold >= min_abs:
+                    threshold = min_abs * 0.5
                 if best_delta >= threshold:
                     if max_step > 0.0:
                         limited_delta = min(best_delta, max_step)

invarlock/guards_ref/rmt_ref.py

@@ -1,37 +1,37 @@
 from __future__ import annotations
 
-import math
 from collections.abc import Mapping
 
 
 def rmt_decide(
-    bare_by_family: Mapping[str, int],
-    guarded_by_family: Mapping[str, int],
+    baseline_by_family: Mapping[str, float],
+    current_by_family: Mapping[str, float],
     epsilon_by_family: Mapping[str, float],
 ) -> dict[str, object]:
     """
-    Reference epsilon-rule decision for RMT.
+    Reference epsilon-rule decision for RMT activation edge-risk drift.
 
-    Allowed excess A_f = ceil(epsilon_f * max(1, b_f)).
-    PASS iff for all families Δ_f <= A_f and sum Δ_f <= sum A_f.
+    For each family with baseline edge-risk > 0:
+        PASS iff current_edge <= (1 + epsilon) * baseline_edge
     """
-    families = set(bare_by_family) | set(guarded_by_family) | set(epsilon_by_family)
-    delta_by_family: dict[str, int] = {}
-    allowed_by_family: dict[str, int] = {}
-    sum_delta = 0
-    sum_allowed = 0
-    for f in families:
-        b = int(bare_by_family.get(f, 0) or 0)
-        g = int(guarded_by_family.get(f, 0) or 0)
-        eps = float(epsilon_by_family.get(f, 0.0) or 0.0)
-        d = g - b
-        a = int(math.ceil(eps * max(1, b)))
-        delta_by_family[f] = d
-        allowed_by_family[f] = a
-        sum_delta += d
-        sum_allowed += a
-    ok = all(delta_by_family[f] <= allowed_by_family[f] for f in families) and (
-        sum_delta <= sum_allowed
+    families = set(baseline_by_family) | set(current_by_family) | set(epsilon_by_family)
+    delta_by_family: dict[str, float] = {}
+    allowed_by_family: dict[str, float] = {}
+    for family in families:
+        baseline = float(baseline_by_family.get(family, 0.0) or 0.0)
+        current = float(current_by_family.get(family, 0.0) or 0.0)
+        if baseline <= 0.0:
+            continue
+        epsilon_val = float(epsilon_by_family.get(family, 0.0) or 0.0)
+        allowed = (1.0 + epsilon_val) * baseline
+        allowed_by_family[family] = allowed
+        delta_by_family[family] = (
+            (current / baseline) - 1.0 if baseline > 0 else float("inf")
+        )
+
+    ok = all(
+        float(current_by_family.get(family, 0.0) or 0.0) <= allowed_by_family[family]
+        for family in allowed_by_family
     )
     return {
         "pass": ok,

invarlock/model_profile.py

@@ -5,12 +5,14 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
 
+AutoTokenizer: Any | None = None
+GPT2Tokenizer: Any | None = None
+
 try:
-    from transformers import AutoTokenizer, GPT2Tokenizer
+    from transformers import AutoTokenizer as _AutoTokenizer
+    from transformers import GPT2Tokenizer as _GPT2Tokenizer
     from transformers.tokenization_utils_base import PreTrainedTokenizerBase
 except Exception:  # pragma: no cover - exercised only when transformers is absent
-    AutoTokenizer = None  # type: ignore[assignment]
-    GPT2Tokenizer = None  # type: ignore[assignment]
 
     class PreTrainedTokenizerBase:  # type: ignore[no-redef]
         """Lightweight stub used when transformers is not installed."""
@@ -22,6 +24,11 @@ except Exception:  # pragma: no cover - exercised only when transformers is abse
             )
 
 
+else:  # pragma: no cover - transformers optional
+    AutoTokenizer = _AutoTokenizer
+    GPT2Tokenizer = _GPT2Tokenizer
+
+
 TokenizerFactory = Callable[[], tuple[PreTrainedTokenizerBase, str]]
 
 
@@ -194,13 +201,24 @@ def _make_llama_tokenizer(model_id: str):
         # Try offline-first to respect InvarLock network guard; fall back to a
         # local GPT-2 tokenizer if the model assets are not cached or network
         # access is denied.
-        try:
-            tokenizer = AutoTokenizer.from_pretrained(model_id, local_files_only=True)
-        except Exception:
+        tokenizer = None
+        if AutoTokenizer is not None:
             try:
-                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                tokenizer = AutoTokenizer.from_pretrained(
+                    model_id, local_files_only=True
+                )
             except Exception:
-                tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+                try:
+                    tokenizer = AutoTokenizer.from_pretrained(model_id)
+                except Exception:
+                    tokenizer = None
+        if tokenizer is None:
+            if GPT2Tokenizer is None:
+                raise RuntimeError(
+                    "Tokenization requires the 'transformers' extra. "
+                    "Install it with: pip install 'invarlock[adapters]'."
+                )
+            tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
         # Ensure padding/bos tokens are configured so downstream encoding
         # yields stable non-zero ids and a valid attention mask regardless of
         # environment defaults or tokenizer variants.
@@ -234,15 +252,24 @@ def _make_unknown_tokenizer(model_id: str):
                 "Install it with: pip install 'invarlock[adapters]'."
             )
         # Unknown families: try local-only first, then remote, then degrade to GPT-2
-        try:
-            tokenizer: PreTrainedTokenizerBase = AutoTokenizer.from_pretrained(
-                model_id, local_files_only=True
-            )
-        except Exception:
+        tokenizer = None
+        if AutoTokenizer is not None:
             try:
-                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                tokenizer = AutoTokenizer.from_pretrained(
+                    model_id, local_files_only=True
+                )
             except Exception:
-                tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+                try:
+                    tokenizer = AutoTokenizer.from_pretrained(model_id)
+                except Exception:
+                    tokenizer = None
+        if tokenizer is None:
+            if GPT2Tokenizer is None:
+                raise RuntimeError(
+                    "Text tokenization requires the 'transformers' extra. "
+                    "Install it with: pip install 'invarlock[adapters]'."
+                )
+            tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
         if getattr(tokenizer, "pad_token", None) is None:
             eos_token = getattr(tokenizer, "eos_token", None)
             if eos_token is not None: