Use d1-3b's code: D1Model in modeling_d1.py

The code of LiquidAI/d1-3b, so the RC loads as `D1Model` instead of the older `LfmJevModel` name.

- `modeling_lfm_jev.py` removed, `modeling_d1.py` added; `config.json`'s `auto_map` points to it
- `prompt.py` and `runner.py`: training-only helpers removed (`row_to_question`, `cardinality`, `option_labels`, `gold_code`, `SYSTEM`, `_logz`); every public call still runs under `torch.inference_mode()`
- Weights, tokenizer, processor, card, LICENSE and assets unchanged

Checked with `trust_remote_code` on the same weights: three questions on a text, one question, a JSON state, an image, an image with text, and a batch of three give the same 44 probabilities as the current code (max difference 0.0).

config.json

@@ -3,7 +3,7 @@
     "Lfm2VlForConditionalGeneration"
   ],
   "auto_map": {
-    "AutoModel": "modeling_lfm_jev.LfmJevModel"
+    "AutoModel": "modeling_d1.D1Model"
   },
   "bos_token_id": 124894,
   "do_image_splitting": true,

lfm2_vl.py

@@ -1,9 +1,9 @@
 """LFM2-VL and LFM2 on the hybrid stack.
 
 HF's classes stay the frame (the SigLIP2 tower, the projector, the image
-features, loading and saving); only the language model is ours, with HF's module
-names, so checkpoints load and save unchanged, and a state
-with any number of questions runs as one `hybrid.Tree`, which matches HF's own
+features, loading and saving); only the language model is replaced, with HF's
+module names, so checkpoints load and save unchanged. A state with any number
+of questions runs as one `hybrid.Tree`, with the same outputs as HF's own
 implementation.
 """
 
@@ -46,7 +46,7 @@ class Attention(nn.Module):
 
 
 class ShortConv(nn.Module):
-    """`out(C * conv(B * x))`; HF's `nn.Conv1d` holds the taps, our causal conv runs them."""
+    """`out(C * conv(B * x))`; HF's `nn.Conv1d` holds the taps, `causal_conv` runs them."""
 
     def __init__(self, cfg):
         super().__init__()

modeling_lfm_jev.py → modeling_d1.py

@@ -14,7 +14,7 @@ from .lfm2_vl import Lfm2VlForConditionalGeneration
 from .runner import SystemOne
 
 
-class LfmJevModel(Lfm2VlForConditionalGeneration):
+class D1Model(Lfm2VlForConditionalGeneration):
     @cached_property
     def engine(self) -> SystemOne:
         from transformers import AutoTokenizer

prompt.py

@@ -20,7 +20,6 @@ SYSTEMS: dict[str, str | None] = {
     ),
 }
 DEFAULT_SYSTEM = "none"
-SYSTEM = SYSTEMS[DEFAULT_SYSTEM]
 
 IM_START = "<|im_start|>"
 IM_END = "<|im_end|>"
@@ -55,20 +54,6 @@ class Score:
 Question = Choice | Noul | Score
 
 
-def row_to_question(row: dict) -> Question:
-    """A row's question (`kind`, `instructions`, `criteria`), as the model is asked it."""
-    kind = row["kind"]
-    if kind == "noul":
-        return Noul(instructions=row["instructions"], criteria=row.get("criteria"))
-    if kind == "score":
-        return Score(instructions=row["instructions"], criteria=list(row["criteria"]))
-    return Choice(instructions=row["instructions"], criteria=row["criteria"])
-
-
-def cardinality(q: Question) -> int:
-    return 2 if isinstance(q, Noul) else len(q.criteria)
-
-
 # --------------------------------------------------------------------------- #
 # verbalizer
 # --------------------------------------------------------------------------- #
@@ -124,12 +109,9 @@ _TOKENIZERS: dict[int, object] = {}
 def aliases(tokenizer, labels: Sequence[str]) -> list[tuple[str, int]]:
     """Assign every label a distinct single-token code: [(code, token_id)].
 
-    Memoised on the codes rather than on the labels. The codes are positional
-    unless the labels are already letters, so two orderings of one option list
-    share an entry, and a 151-option inventory question does not re-derive its
-    codes once per permuted row. Keying on the label tuple instead misses on
-    every such row. Measured against a contended node it was not the cost it
-    first looked like, but the entry is the codes and the key should say so.
+    Memoised on the codes rather than on the labels: the codes are positional
+    unless the labels are already letters, so every option list of one length
+    shares an entry.
     """
     _TOKENIZERS.setdefault(id(tokenizer), tokenizer)
     codes = tuple(option_codes(labels))
@@ -209,36 +191,16 @@ def readout(tokenizer, q: Question, logz, calibration=None) -> list[float]:
     return [e / sum(exps) for e in exps]
 
 
-def option_labels(q: Question) -> list[str]:
-    if isinstance(q, Noul):
-        return ["yes", "no"]
-    if isinstance(q, Score):
-        return [str(i) for i in range(len(q.criteria))]
-    return list(q.criteria.keys())
-
-
-def gold_code(tokenizer, q: Question, gold: str | int) -> str:
-    """The exact string the model must produce in the answer slot."""
-    if isinstance(q, Noul):
-        if isinstance(gold, str):
-            return "yes" if gold.strip().lower() in {"yes", "true", "1"} else "no"
-        return "yes" if int(gold) == 1 else "no"
-    if isinstance(q, Score):
-        return str(int(gold))
-    labels = list(q.criteria.keys())
-    idx = labels.index(gold) if gold in labels else int(gold)
-    return aliases(tokenizer, labels)[idx][0]
-
-
 # --------------------------------------------------------------------------- #
 # state and question rendering
 # --------------------------------------------------------------------------- #
 
 
+DEFAULT_MODEL = "LiquidAI/LFM2.5-VL-3B"
+
 # How a state is rendered: `json_only`, the default, writes every state as the object it is; `json` keeps
 # three shortcuts (`Message:`, `Passage:` / `Asked:`, a lone question's text); `sections` writes nested
 # states as labelled blocks.
-DEFAULT_MODEL = "LiquidAI/LFM2.5-VL-3B"
 DEFAULT_STATE_STYLE = "json_only"
 
 
@@ -249,9 +211,8 @@ def _is_scalar(v: Any) -> bool:
 def _sections(obj: Any, path: str, out: list[str]) -> None:  # noqa: C901
     """Flatten a nested state into labelled blocks, keeping real newlines.
 
-    A caller's state is JSON, but `json.dumps` escapes every newline inside a
-    log line or a record, so a 40-line CrowdStrike host record arrives as one
-    unreadable string of `\n`. The model reads a case file, not a payload.
+    `json.dumps` escapes every newline inside a log line or a record, so a
+    multi-line record would arrive as one string of `\n`; this keeps it readable.
     """
     head = f"[{path}]\n" if path else ""
     if isinstance(obj, dict):
@@ -358,8 +319,8 @@ def prefix_text(
     return f"{bos}{turn}{IM_START}user\n{images}{body}"
 
 
-# What sits between the assistant header and the answer slot: nothing on LFM2-VL, whose template opens
-# no reasoning block, so the slot is already clean. A family module can add its own (`LEADS`).
+# What sits between the assistant header and the answer slot, per model type: nothing on LFM2-VL, whose
+# template opens no reasoning block.
 DEFAULT_LEAD = ""
 LEADS: dict[str, str] = {}
 

runner.py

@@ -39,7 +39,7 @@ MODELS = {
 
 
 def load_backbone(model_id: str = DEFAULT_MODEL, dtype=torch.bfloat16):
-    """The checkpoint and its tokenizer. SigLIP2 has no FA2 kernel here, so SDPA."""
+    """The checkpoint and its tokenizer, with SDPA attention."""
     from transformers import AutoModelForImageTextToText, AutoTokenizer, PretrainedConfig
 
     tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
@@ -82,8 +82,8 @@ class SystemOne(SystemOneApi):
         model=None,
         tokenizer=None,
     ):
-        """`model` and `tokenizer`, when given, are a backbone already loaded (the Hub's remote-code class
-        passes itself); it stays on its device unless `device` says otherwise."""
+        """`model` and `tokenizer`, when given, are a backbone already loaded (`D1Model` passes itself);
+        it stays on its device unless `device` says otherwise."""
         if model is None:
             model, tokenizer = load_backbone(model_id)
         else:
@@ -103,8 +103,7 @@ class SystemOne(SystemOneApi):
         self.option_style = option_style
         self.token_budget = token_budget
         self.processor = None
-        # CUDA graphs for single questions, on NVIDIA: where eager time is kernel launches, 16 to 8 ms a
-        # decision on an RTX 4090. The first two prompt lengths compile; later ones reuse the dynamic graph.
+        # CUDA graphs for single questions on NVIDIA, where eager time is mostly kernel launches.
         if compile and torch.version.hip:
             raise ValueError("compile=True needs CUDA: on ROCm the CUDA graphs fault after a few dozen calls")
         self._one_pass = (torch.compile(self.model.forward, mode="reduce-overhead")
@@ -120,19 +119,14 @@ class SystemOne(SystemOneApi):
 
     # --------------------------------------------------------------- forward
 
-    @torch.inference_mode()
-    def _logz(self, texts: Sequence[str], questions: Sequence[Question] | None = None) -> list[torch.Tensor]:
-        """Log-softmax at the answer slot, one row per text, in one pass; the slot needs only the texts, and
-        `questions` is accepted for the scoring interface.
+    def _logz_ids(self, rows: list[list[int]]) -> list[torch.Tensor]:
+        """Log-softmax at the answer slot, one row per token list, in one pass.
 
         The rows are one tree (`hybrid.py`): their common start is its trunk and
         is read once; the rest of each row is a branch, packed with no padding.
         Mathematically each row alone; in bf16 the kernels differ by batch shape.
         """
-        return self._logz_ids([self.tokenizer.encode(t, add_special_tokens=False) for t in texts])
-
-    def _logz_ids(self, rows: list[list[int]]) -> list[torch.Tensor]:
-        if len(rows) == 1:  # nothing to share: a plain chain, 6-12% faster than a tree of one
+        if len(rows) == 1:  # nothing to share: a plain chain is faster than a tree of one
             row = self._one_pass(input_ids=torch.tensor(rows, device=self.device), logits_to_keep=1).logits[0, -1]
             return [row.float() - torch.logsumexp(row.float(), dim=-1)]
         shared = 0  # every row keeps at least its last token