invarlock 0.3.5__py3-none-any.whl → 0.3.7__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(
@@ -121,7 +121,7 @@ def _iter_transformer_layers(model: nn.Module):
         # GPT-2 style
         yield from model.transformer.h
     elif hasattr(model, "model") and hasattr(model.model, "layers"):
-        # LLaMA style
+        # RoPE decoder style
         yield from model.model.layers
     elif hasattr(model, "encoder") and hasattr(model.encoder, "layer"):
         # BERT style
@@ -214,7 +214,7 @@ def equalise_residual_variance(
                 hooks[name] = attn_proj.register_forward_hook(_branch_hook(name))
 
         if hasattr(blk, "mlp"):
-            # Check for c_proj (GPT-2) or down_proj (LLaMA) or fc2 (generic)
+            # Check for c_proj (GPT-2) or down_proj (RoPE decoder) or fc2 (generic)
             mlp_proj = (
                 getattr(blk.mlp, "c_proj", None)
                 or getattr(blk.mlp, "down_proj", None)
@@ -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]]
 
 
@@ -99,7 +106,7 @@ def _gpt2_selectors() -> dict[str, list[str]]:
     }
 
 
-def _llama_selectors() -> dict[str, list[str]]:
+def _rope_decoder_selectors() -> dict[str, list[str]]:
     return {
         "attention": [
             "self_attn.q_proj",
@@ -184,23 +191,34 @@ def _make_gpt2_tokenizer(model_id: str):
     return factory
 
 
-def _make_llama_tokenizer(model_id: str):
+def _make_causal_auto_tokenizer(model_id: str):
     def factory() -> tuple[PreTrainedTokenizerBase, str]:
         if AutoTokenizer is None and GPT2Tokenizer is None:
             raise RuntimeError(
-                "LLaMA-style tokenizers require the 'transformers' extra. "
+                "Causal tokenizers require the 'transformers' extra. "
                 "Install it with: pip install 'invarlock[adapters]'."
             )
         # 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.
@@ -209,7 +227,7 @@ def _make_llama_tokenizer(model_id: str):
             eos_token = getattr(tokenizer, "eos_token", None)
             if eos_token is not None:
                 tokenizer.pad_token = eos_token
-        # Some LLaMA tokenizers default to not adding a BOS token on encode;
+        # Some causal tokenizers default to not adding a BOS token on encode;
         # enable it to guarantee at least one non-pad, non-zero token id.
         if hasattr(tokenizer, "add_bos_token"):
             try:
@@ -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:
@@ -262,7 +289,7 @@ def detect_model_profile(model_id: str, adapter: str | None = None) -> ModelProf
     model_lower = (model_id or "").lower()
 
     if any(
-        keyword in adapter_lower for keyword in ("bert", "roberta", "deberta")
+        keyword in adapter_lower for keyword in ("hf_mlm", "bert", "roberta", "deberta")
     ) or any(keyword in model_lower for keyword in ("bert", "roberta", "deberta")):
         return ModelProfile(
             family="bert",
@@ -275,57 +302,78 @@ def detect_model_profile(model_id: str, adapter: str | None = None) -> ModelProf
             cert_lints=(
                 {
                     "type": "equals",
-                    "path": "metrics.loss_type",
-                    "value": "mlm",
-                    "message": "BERT cert must record MLM loss type.",
+                    "path": "primary_metric.kind",
+                    "value": "ppl_mlm",
+                    "message": "BERT cert must use MLM metric.",
                 },
                 {
                     "type": "gte",
-                    "path": "metrics.masked_tokens_total",
+                    "path": "telemetry.masked_tokens_total",
                     "value": "1",
                     "message": "BERT cert must report masked tokens.",
                 },
             ),
         )
 
-    if any(keyword in adapter_lower for keyword in ("llama", "mistral", "qwen")) or any(
-        keyword in model_lower for keyword in ("llama", "mistral", "qwen")
+    if any(keyword in adapter_lower for keyword in ("hf_seq2seq", "t5", "bart")) or any(
+        keyword in model_lower for keyword in ("t5", "bart")
     ):
         return ModelProfile(
-            family="llama",
+            family="seq2seq",
+            default_loss="seq2seq",
+            make_tokenizer=_make_unknown_tokenizer(model_id),
+            default_metric="ppl_seq2seq",
+            default_provider="wikitext2",
+            module_selectors=_unknown_selectors(),
+            invariants=(),
+            cert_lints=(),
+        )
+
+    if any(
+        keyword in adapter_lower for keyword in ("gpt", "neox", "opt", "phi")
+    ) or any(keyword in model_lower for keyword in ("gpt", "neox", "opt", "phi")):
+        return ModelProfile(
+            family="gpt2",
             default_loss="causal",
-            make_tokenizer=_make_llama_tokenizer(model_id),
+            make_tokenizer=_make_gpt2_tokenizer(model_id),
             default_metric="ppl_causal",
             default_provider="wikitext2",
-            module_selectors=_llama_selectors(),
-            invariants=("rope_rotary_embedding",),
+            module_selectors=_gpt2_selectors(),
+            invariants=("causal_masking",),
             cert_lints=(
                 {
                     "type": "equals",
-                    "path": "metrics.loss_type",
-                    "value": "causal",
-                    "message": "LLaMA cert should report causal loss.",
+                    "path": "primary_metric.kind",
+                    "value": "ppl_causal",
+                    "message": "GPT-style cert must use causal ppl metric.",
                 },
             ),
         )
 
     if any(
-        keyword in adapter_lower for keyword in ("gpt", "neox", "opt", "phi")
-    ) or any(keyword in model_lower for keyword in ("gpt", "neox", "opt", "phi")):
+        keyword in adapter_lower for keyword in ("mistral", "mixtral", "qwen", "yi")
+    ) or any(
+        keyword in model_lower for keyword in ("mistral", "mixtral", "qwen", "yi")
+    ):
+        family = "causal"
+        for keyword in ("mixtral", "mistral", "qwen", "yi"):
+            if keyword in adapter_lower or keyword in model_lower:
+                family = keyword
+                break
         return ModelProfile(
-            family="gpt2",
+            family=family,
             default_loss="causal",
-            make_tokenizer=_make_gpt2_tokenizer(model_id),
+            make_tokenizer=_make_causal_auto_tokenizer(model_id),
             default_metric="ppl_causal",
             default_provider="wikitext2",
-            module_selectors=_gpt2_selectors(),
-            invariants=("causal_masking",),
+            module_selectors=_rope_decoder_selectors(),
+            invariants=("rope_rotary_embedding",),
             cert_lints=(
                 {
                     "type": "equals",
-                    "path": "metrics.loss_type",
-                    "value": "causal",
-                    "message": "GPT-style cert should record causal loss.",
+                    "path": "primary_metric.kind",
+                    "value": "ppl_causal",
+                    "message": "Causal cert must use causal ppl metric.",
                 },
             ),
         )

invarlock/observability/health.py

@@ -374,15 +374,15 @@ class InvarLockHealthChecker(HealthChecker):
             """Check adapter availability."""
             try:
                 from invarlock.adapters import (
-                    HF_BERT_Adapter,
-                    HF_GPT2_Adapter,
-                    HF_LLaMA_Adapter,
+                    HF_Causal_Adapter,
+                    HF_MLM_Adapter,
+                    HF_Seq2Seq_Adapter,
                 )
 
                 adapters = {
-                    "hf_gpt2": HF_GPT2_Adapter,
-                    "hf_llama": HF_LLaMA_Adapter,
-                    "hf_bert": HF_BERT_Adapter,
+                    "hf_causal": HF_Causal_Adapter,
+                    "hf_mlm": HF_MLM_Adapter,
+                    "hf_seq2seq": HF_Seq2Seq_Adapter,
                 }
 
                 available_adapters = []

invarlock/observability/metrics.py

@@ -455,3 +455,111 @@ def create_resource_metrics(registry: MetricsRegistry) -> dict[str, Any]:
         "gpu_memory": registry.register_gauge("invarlock.resource.gpu_memory_percent"),
         "disk_usage": registry.register_gauge("invarlock.resource.disk_percent"),
     }
+
+
+def reset_peak_memory_stats() -> None:
+    """Reset GPU peak memory stats when available."""
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+        mps = getattr(torch, "mps", None)
+        if mps is not None and hasattr(mps, "reset_peak_memory_stats"):
+            mps.reset_peak_memory_stats()
+    except Exception:
+        pass
+
+
+def capture_memory_snapshot(
+    phase: str, *, timestamp: float | None = None
+) -> dict[str, Any]:
+    """Capture a point-in-time memory snapshot for the current process."""
+    snapshot: dict[str, Any] = {"phase": str(phase)}
+    if timestamp is None:
+        timestamp = time.time()
+    snapshot["ts"] = float(timestamp)
+
+    try:
+        import os
+
+        import psutil
+
+        process = psutil.Process(os.getpid())
+        rss_mb = process.memory_info().rss / 1024 / 1024
+        snapshot["rss_mb"] = float(rss_mb)
+    except Exception:
+        pass
+
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            device_index = torch.cuda.current_device()
+            snapshot["gpu_device"] = f"cuda:{device_index}"
+            snapshot["gpu_mb"] = float(
+                torch.cuda.memory_allocated(device_index) / 1024 / 1024
+            )
+            snapshot["gpu_reserved_mb"] = float(
+                torch.cuda.memory_reserved(device_index) / 1024 / 1024
+            )
+            snapshot["gpu_peak_mb"] = float(
+                torch.cuda.max_memory_allocated(device_index) / 1024 / 1024
+            )
+            snapshot["gpu_peak_reserved_mb"] = float(
+                torch.cuda.max_memory_reserved(device_index) / 1024 / 1024
+            )
+        else:
+            mps = getattr(torch, "mps", None)
+            if mps is not None and hasattr(torch.backends, "mps"):
+                if torch.backends.mps.is_available():
+                    snapshot["gpu_device"] = "mps"
+                    if hasattr(mps, "current_allocated_memory"):
+                        snapshot["gpu_mb"] = float(
+                            mps.current_allocated_memory() / 1024 / 1024
+                        )
+                    if hasattr(mps, "driver_allocated_memory"):
+                        snapshot["gpu_reserved_mb"] = float(
+                            mps.driver_allocated_memory() / 1024 / 1024
+                        )
+    except Exception:
+        pass
+
+    if len(snapshot) <= 2:
+        return {}
+    return snapshot
+
+
+def summarize_memory_snapshots(
+    snapshots: list[dict[str, Any]],
+) -> dict[str, float]:
+    """Summarize memory snapshots into peak metrics."""
+
+    def _peak(key: str) -> float | None:
+        values: list[float] = []
+        for entry in snapshots:
+            if not isinstance(entry, dict):
+                continue
+            value = entry.get(key)
+            if isinstance(value, int | float):
+                values.append(float(value))
+        return max(values) if values else None
+
+    summary: dict[str, float] = {}
+    rss_peak = _peak("rss_mb")
+    if rss_peak is not None:
+        summary["memory_mb_peak"] = rss_peak
+
+    gpu_peak = _peak("gpu_peak_mb")
+    if gpu_peak is None:
+        gpu_peak = _peak("gpu_mb")
+    if gpu_peak is not None:
+        summary["gpu_memory_mb_peak"] = gpu_peak
+
+    gpu_reserved_peak = _peak("gpu_peak_reserved_mb")
+    if gpu_reserved_peak is None:
+        gpu_reserved_peak = _peak("gpu_reserved_mb")
+    if gpu_reserved_peak is not None:
+        summary["gpu_memory_reserved_mb_peak"] = gpu_reserved_peak
+
+    return summary