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

invarlock/adapters/hf_loading.py

@@ -50,7 +50,7 @@ def resolve_trust_remote_code(
     return default
 
 
-def default_torch_dtype() -> torch.dtype:
+def default_dtype() -> torch.dtype:
     """Pick a safe default dtype for HF loads based on hardware."""
     if torch.cuda.is_available():
         try:
@@ -69,10 +69,10 @@ def default_torch_dtype() -> torch.dtype:
     return torch.float32
 
 
-def resolve_torch_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | str:
-    """Resolve torch_dtype from kwargs or choose a hardware-aware default."""
-    if kwargs and "torch_dtype" in kwargs:
-        val = kwargs.get("torch_dtype")
+def resolve_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | str:
+    """Resolve dtype from kwargs or choose a hardware-aware default."""
+    if kwargs and "dtype" in kwargs:
+        val = kwargs.get("dtype")
         if isinstance(val, torch.dtype):
             return val
         if isinstance(val, str):
@@ -91,7 +91,7 @@ def resolve_torch_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | s
             if s in mapping:
                 return mapping[s]
 
-    return default_torch_dtype()
+    return default_dtype()
 
 
-__all__ = ["resolve_trust_remote_code", "default_torch_dtype", "resolve_torch_dtype"]
+__all__ = ["resolve_trust_remote_code", "default_dtype", "resolve_dtype"]

invarlock/adapters/hf_mixin.py

@@ -490,18 +490,39 @@ class HFAdapterMixin:
         """Return mapping of tied parameter names to source parameter names."""
 
         tying: dict[str, str] = {}
-        param_names = set(dict(model.named_parameters()).keys())
+        try:
+            named = model.named_parameters(remove_duplicate=False)  # type: ignore[call-arg]
+        except TypeError:  # pragma: no cover - torch version dependent
+            named = model.named_parameters()
+        params = dict(named)
+
+        def _is_tied(name_a: str, name_b: str) -> bool:
+            a = params.get(name_a)
+            b = params.get(name_b)
+            if a is None or b is None:
+                return False
+            try:
+                if a is b:
+                    return True
+                if hasattr(a, "data_ptr") and hasattr(b, "data_ptr"):
+                    return int(a.data_ptr()) == int(b.data_ptr())
+            except Exception:
+                return False
+            return False
 
-        if "lm_head.weight" in param_names and "transformer.wte.weight" in param_names:
+        if _is_tied("lm_head.weight", "transformer.wte.weight"):
             tying["lm_head.weight"] = "transformer.wte.weight"
 
+        if _is_tied("lm_head.weight", "model.embed_tokens.weight"):
+            tying["lm_head.weight"] = "model.embed_tokens.weight"
+
         decoder_name = "cls.predictions.decoder.weight"
-        if decoder_name in param_names:
+        if decoder_name in params:
             for candidate in (
                 "bert.embeddings.word_embeddings.weight",
                 "embeddings.word_embeddings.weight",
             ):
-                if candidate in param_names:
+                if _is_tied(decoder_name, candidate):
                     tying[decoder_name] = candidate
                     break
 
@@ -562,22 +583,45 @@ class HFAdapterMixin:
     def _serialize_config(self, config: Any) -> dict[str, Any]:
         """Serialize HuggingFace config fields into simple Python types."""
 
+        def _collect(data: dict[str, Any]) -> dict[str, Any]:
+            out: dict[str, Any] = {}
+            for key, value in data.items():
+                if key.startswith("_") or key in {"method_calls"}:
+                    continue
+                if value is None or isinstance(value, SCALAR_TYPES):
+                    out[key] = value
+                elif isinstance(value, list | dict):
+                    out[key] = value
+            return out
+
+        to_dict = getattr(config, "to_dict", None)
+        if callable(to_dict):
+            try:
+                data = to_dict()
+            except Exception:
+                data = None
+            if isinstance(data, dict):
+                return _collect(data)
+
+        try:
+            data = vars(config)
+        except TypeError:
+            data = None
+        if isinstance(data, dict):
+            return _collect(data)
+
         result: dict[str, Any] = {}
         for key in dir(config):
-            if key.startswith("_"):
+            if key.startswith("_") or key in {"torch_dtype"}:
                 continue
-
             try:
                 value = getattr(config, key)
             except AttributeError:
                 continue
-
             if callable(value):
                 continue
-
             if value is None or isinstance(value, SCALAR_TYPES):
                 result[key] = value
             elif isinstance(value, list | dict):
                 result[key] = value
-
         return result

invarlock/adapters/{hf_bert.py → hf_mlm.py}

@@ -1,15 +1,8 @@
 """
-HuggingFace BERT Model Adapter
+HuggingFace masked LM adapter.
 ==============================
 
-ModelAdapter implementation for HuggingFace BERT architecture models.
-
-This adapter provides BERT-specific integration including:
-- Support for BERT, RoBERTa, DistilBERT, and other BERT variants
-- Proper handling of bidirectional attention layers
-- Support for classification heads and pooling layers
-- Token type embeddings and position embeddings handling
-- Proper device-aware state serialization
+ModelAdapter implementation for HuggingFace masked language models.
 """
 
 from typing import Any
@@ -27,7 +20,7 @@ TensorType = torch.Tensor
 ModuleType = nn.Module
 
 
-class HF_BERT_Adapter(HFAdapterMixin, ModelAdapter):
+class HF_MLM_Adapter(HFAdapterMixin, ModelAdapter):
     """
     HuggingFace-specific ModelAdapter implementation for BERT models.
 
@@ -39,7 +32,7 @@ class HF_BERT_Adapter(HFAdapterMixin, ModelAdapter):
     - Device-aware state serialization
     """
 
-    name = "hf_bert"
+    name = "hf_mlm"
 
     def load_model(
         self, model_id: str, device: str = "auto", **kwargs: Any

invarlock/adapters/{hf_t5.py → hf_seq2seq.py}

@@ -1,11 +1,11 @@
 """
-HuggingFace T5 Model Adapter
-============================
+HuggingFace encoder-decoder adapter.
+===================================
 
-ModelAdapter implementation for HuggingFace T5 encoder-decoder models.
+ModelAdapter implementation for HuggingFace encoder-decoder (seq2seq) models.
 
-Loads AutoModelForSeq2SeqLM (e.g., t5-small/base/large) and exposes a minimal
-describe() sufficient for guard policies and reporting.
+Loads AutoModelForSeq2SeqLM and exposes a minimal describe() sufficient for
+guard policies and reporting.
 """
 
 from __future__ import annotations
@@ -25,10 +25,10 @@ TensorType = torch.Tensor
 ModuleType = nn.Module
 
 
-class HF_T5_Adapter(HFAdapterMixin, ModelAdapter):
-    """HuggingFace T5 adapter using AutoModelForSeq2SeqLM."""
+class HF_Seq2Seq_Adapter(HFAdapterMixin, ModelAdapter):
+    """HuggingFace encoder-decoder adapter using AutoModelForSeq2SeqLM."""
 
-    name = "hf_t5"
+    name = "hf_seq2seq"
 
     def load_model(  # type: ignore[override]
         self, model_id: str, device: str = "auto", **kwargs: Any
@@ -136,4 +136,4 @@ class HF_T5_Adapter(HFAdapterMixin, ModelAdapter):
         return super().restore(model, blob)
 
 
-__all__ = ["HF_T5_Adapter"]
+__all__ = ["HF_Seq2Seq_Adapter"]

invarlock/assurance/__init__.py

@@ -1,8 +1,4 @@
-"""Assurance namespace (`invarlock.assurance`).
-
-This namespace groups safety-certificate related surfaces. For now it forwards
-to `invarlock.eval` and guard modules; future work may move implementations here.
-"""
+"""Assurance namespace (`invarlock.assurance`)."""
 
 from __future__ import annotations
 
@@ -11,33 +7,29 @@ from typing import Any
 from invarlock.reporting.report_types import RunReport
 
 try:  # pragma: no cover - shim to reporting modules
-    from invarlock.reporting.certificate import (
-        CERTIFICATE_SCHEMA_VERSION,
-        make_certificate,
-        validate_certificate,
-    )
-
     # Prefer direct import from render for rendering APIs
-    from invarlock.reporting.render import render_certificate_markdown
+    from invarlock.reporting.render import render_report_markdown
+    from invarlock.reporting.report_builder import make_report
+    from invarlock.reporting.report_schema import REPORT_SCHEMA_VERSION, validate_report
 except Exception:  # pragma: no cover - provide soft stubs
-    CERTIFICATE_SCHEMA_VERSION = "v1"
+    REPORT_SCHEMA_VERSION = "v1"
 
-    def make_certificate(
+    def make_report(
         report: RunReport,
         baseline: RunReport | dict[str, Any],
     ) -> dict[str, Any]:
-        raise ImportError("invarlock.reporting.certificate not available")
+        raise ImportError("invarlock.reporting.report_builder not available")
 
-    def render_certificate_markdown(certificate: dict[str, Any]) -> str:
-        raise ImportError("invarlock.reporting.certificate not available")
+    def render_report_markdown(evaluation_report: dict[str, Any]) -> str:
+        raise ImportError("invarlock.reporting.report_builder not available")
 
-    def validate_certificate(certificate: dict[str, Any]) -> bool:
-        raise ImportError("invarlock.reporting.certificate not available")
+    def validate_report(report: dict[str, Any]) -> bool:
+        raise ImportError("invarlock.reporting.report_schema not available")
 
 
 __all__ = [
-    "CERTIFICATE_SCHEMA_VERSION",
-    "make_certificate",
-    "render_certificate_markdown",
-    "validate_certificate",
+    "REPORT_SCHEMA_VERSION",
+    "make_report",
+    "render_report_markdown",
+    "validate_report",
 ]

invarlock/cli/adapter_auto.py

@@ -2,7 +2,8 @@
 Auto adapter resolution utilities.
 
 These helpers map a model identifier (HF directory or Hub ID) to a
-concrete built-in adapter name (hf_gpt2, hf_llama, hf_bert) without
+concrete built-in adapter name (hf_causal, hf_mlm, hf_seq2seq, hf_causal_onnx)
+without
 adding a hard dependency on Transformers.
 """
 
@@ -46,11 +47,7 @@ def _detect_quant_family_from_cfg(cfg: dict[str, Any]) -> str | None:
                 return "hf_gptq"
             if any(tok in method for tok in ("awq",)):
                 return "hf_awq"
-            # BitsAndBytes style
-            if any(
-                str(q.get(k, "")).lower() in {"true", "1"}
-                for k in ("load_in_4bit", "load_in_8bit")
-            ) or any("bitsandbytes" in str(v).lower() for v in q.values()):
+            if "bitsandbytes" in method or "bnb" in method:
                 return "hf_bnb"
     except Exception:
         return None
@@ -58,15 +55,15 @@ def _detect_quant_family_from_cfg(cfg: dict[str, Any]) -> str | None:
 
 
 def resolve_auto_adapter(
-    model_id: str | os.PathLike[str], default: str = "hf_gpt2"
+    model_id: str | os.PathLike[str], default: str = "hf_causal"
 ) -> str:
     """Resolve an appropriate built-in adapter name for a model.
 
     Heuristics:
       - Prefer local config.json (no network). Inspect `model_type` and
-        `architectures` to classify LLaMA/Mistral vs BERT vs GPT-like.
+        `architectures` to classify causal vs masked-LM vs seq2seq.
       - Fallback to simple name heuristics on the model_id string.
-      - Default to `hf_gpt2` when unsure.
+      - Default to `hf_causal` when unsure.
     """
     cfg = _read_local_hf_config(model_id)
     model_id_str = str(model_id)
@@ -77,32 +74,41 @@ def resolve_auto_adapter(
         if fam:
             return fam
         mt = str(c.get("model_type", "")).lower()
+        if bool(c.get("is_encoder_decoder", False)):
+            return "hf_seq2seq"
         archs = [str(a) for a in c.get("architectures", []) if isinstance(a, str)]
         arch_blob = " ".join(archs)
-        if (
-            mt in {"llama", "mistral", "qwen", "yi"}
-            or "Llama" in arch_blob
-            or "Mistral" in arch_blob
-        ):
-            return "hf_llama"
+        if "ConditionalGeneration" in arch_blob or "Seq2SeqLM" in arch_blob:
+            return "hf_seq2seq"
         # Treat masked-LM families as BERT-like
         if (
             mt in {"bert", "roberta", "distilbert", "albert", "deberta", "deberta-v2"}
             or "MaskedLM" in arch_blob
         ):
-            return "hf_bert"
-        # Generic causal LM
-        if "CausalLM" in arch_blob or mt in {
+            return "hf_mlm"
+        # Causal LM families (best-effort; structural validation happens in the adapter).
+        if "CausalLM" in arch_blob or "ForCausalLM" in arch_blob:
+            return "hf_causal"
+        if mt in {
+            "mistral",
+            "mixtral",
+            "qwen",
+            "qwen2",
+            "qwen2_moe",
+            "yi",
             "gpt2",
             "gpt_neox",
             "opt",
             "gptj",
-            "gptj8bit",
+            "phi",
+            "falcon",
+            "glm",
+            "deepseek",
         }:
-            return "hf_gpt2"
+            return "hf_causal"
         return None
 
-    # If local directory contains ONNX model files, prefer hf_onnx
+    # If local directory contains ONNX model files, prefer the ONNX causal adapter.
     try:
         p = Path(model_id)
         if p.exists() and p.is_dir():
@@ -114,7 +120,7 @@ def resolve_auto_adapter(
                 "encoder_model.onnx",
             ]
             if any((p / fname).exists() for fname in onnx_files):
-                return "hf_onnx"
+                return "hf_causal_onnx"
     except Exception:
         pass
 
@@ -134,10 +140,10 @@ def resolve_auto_adapter(
         k in lower_id for k in ["bnb", "bitsandbytes", "-4bit", "-8bit", "4bit", "8bit"]
     ):
         return "hf_bnb"
-    if any(k in lower_id for k in ["llama", "mistral", "qwen", "yi"]):
-        return "hf_llama"
+    if any(k in lower_id for k in ["t5", "bart"]):
+        return "hf_seq2seq"
     if any(k in lower_id for k in ["bert", "roberta", "albert", "deberta"]):
-        return "hf_bert"
+        return "hf_mlm"
     return default
 
 
@@ -148,7 +154,7 @@ def apply_auto_adapter_if_needed(cfg: Any) -> Any:
     """
     try:
         adapter = str(getattr(cfg.model, "adapter", ""))
-        if adapter.strip().lower() not in {"auto", "hf_auto", "auto_hf"}:
+        if adapter.strip().lower() not in {"auto", "auto_hf"}:
             return cfg
         model_id = str(getattr(cfg.model, "id", ""))
         resolved = resolve_auto_adapter(model_id)