Add benchmark adapters for released models

README.md

@@ -67,6 +67,7 @@ At 0.5, SecureBERT2.0 flags nearly every security method. Its high F1 therefore
 ## Files
 
 - [`benchmark.py`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/benchmark.py): run a model on the public pairs and calculate the metrics in these tables.
+- [`adapters/`](https://huggingface.co/datasets/perchscan/benchmark-results/tree/main/adapters): example runners for the unmodified open-source models in the tables.
 - `results.jsonl`: one aggregate report per domain, track, model, and protocol.
 - `split-summary.json`: split sizes and whole-file SHA-256 values. It contains no private rows or repository list.
 - `predictions/`: public-pair probabilities for auditing the public scores. No private predictions are included.

adapters/README.md

@@ -0,0 +1,42 @@
+# Released-model benchmark adapters
+
+These scripts connect the [Perch benchmark runner](../benchmark.py) to the unmodified, publicly released models in the results table. Each process reads one JSON request per line and writes `{"score": probability}` per line. Scores are for the supplied method side; the adapter never sees its paired repair or label.
+
+Install the relevant model's upstream dependencies before running it. A small smoke run uses `--limit 2`; rerunning the same command resumes the prediction file. Remove `--limit` to finish and write the metric report.
+
+## JevK5
+
+Install the [JevK5 runtime](https://github.com/allebee/jevk5) and `huggingface_hub`. The adapter pins the v0.2 model used in the published result. If already downloaded, set `JEVK5_MODEL` to that snapshot directory.
+
+```sh
+python3 benchmark.py run --domain bug --scorer command --command 'python3 adapters/jevk5.py' --model-revision 'alibiserikbay/JevK5@3c673298eb7f2dc7cb98019262c55b1fac01a0bc' --protocol-id perch-broad-v1 --predictions bug-jevk5.jsonl --report bug-jevk5.json --limit 2
+```
+
+## jev-lite
+
+Install `torch`, `transformers`, `peft`, and `huggingface_hub`. The adapter pins both the [Gemma base](https://huggingface.co/google/gemma-4-E4B-it) and [jev-lite adapter](https://huggingface.co/vagmi/jev-lite) revisions from the published run. Set `JEV_LITE_BASE` and `JEV_LITE_ADAPTER` to local snapshots to avoid downloading them again. Gemma access may require accepting its license on Hugging Face.
+
+```sh
+python3 benchmark.py run --domain bug --scorer command --command 'python3 adapters/jev_lite.py' --model-revision 'vagmi/jev-lite@90b23bc26c53f5a897684456893b2b7edeb90297' --protocol-id perch-broad-v1 --predictions bug-jev-lite.jsonl --report bug-jev-lite.json --limit 2
+```
+
+## SecureBERT2.0
+
+Install `torch`, `transformers`, and `huggingface_hub`. This security-only adapter formats and truncates Perch context to the 4,096-token input used for the published run. The exact upstream snapshot revision was not recorded for that run, so set `SECUREBERT_MODEL` to a chosen local snapshot and record its revision with your result.
+
+```sh
+python3 benchmark.py run --domain security --scorer command --command 'python3 adapters/securebert.py' --model-revision 'cisco-ai/SecureBERT2.0-code-vuln-detection@YOUR_REVISION' --protocol-id perch-security-state-4096-v1 --predictions security-securebert.jsonl --report security-securebert.json --limit 2
+```
+
+## CLM-v0.1-8B
+
+Clone the [CLM source](https://github.com/Contrastive-LM/CLM), set `CLM_REPO` to the checkout, and install its dependencies plus `torch`, `numpy`, and `huggingface_hub`. Run a vLLM Qwen3-8B pooling endpoint with a context length of at least 6,144 tokens. Set `CLM_EMBED_URL` if it is not `http://127.0.0.1:8090/v1/embeddings`. The adapter checks the released choice-head file hash and uses the same method formatting and 6,144-token embedding recipe as the published run.
+
+```sh
+export CLM_REPO=/path/to/CLM
+vllm serve Qwen/Qwen3-8B --runner pooling --max-model-len 6144 --port 8090
+# In another shell:
+python3 benchmark.py run --domain bug --scorer command --command 'python3 adapters/clm.py' --model-revision 'Contrastive-LM/CLM-v0.1-8B@sha256:b2b4a8c9c2d39263eff78a351eb909a342ce9b3bf21a3f07c1d1bf15f1c4eda5' --protocol-id clm-native-choice-6144-v1 --predictions bug-clm.jsonl --report bug-clm.json --limit 2
+```
+
+The CLM adapter uses its native choice prompts, while the other adapters use the broad bug or security question where the model accepts one. Input length and model revisions affect results. These scripts contain no benchmark labels, API keys, private data, or fine-tuned weights.

adapters/clm.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Persistent benchmark adapter for the released CLM-v0.1-8B choice heads.
+
+Requires the upstream CLM checkout and a Qwen3-8B vLLM pooling endpoint.
+See adapters/README.md for setup. This is the 6,144-token benchmark protocol.
+"""
+
+import contextlib
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+
+from huggingface_hub import hf_hub_download
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+
+repo = Path(os.environ["CLM_REPO"])
+sys.path.insert(0, str(repo / "src"))
+sys.path.insert(0, str(repo / "train"))
+from clm.heads import make_head  # noqa: E402
+from clm.schema import build_pairs  # noqa: E402
+from embed_utils import Recipe, ServerBackend  # noqa: E402
+
+
+QUESTIONS = {
+    "bug": {
+        "type": "noul",
+        "instructions": "Does this method contain a functional bug that can cause incorrect behavior in the current code?",
+        "criteria": {
+            "false": "The current method has no functional bug causing incorrect behavior.",
+            "true": "The current method has a functional bug causing incorrect behavior.",
+        },
+    },
+    "security": {
+        "type": "noul",
+        "instructions": "Does this method contain a security vulnerability exploitable in the current code?",
+        "criteria": {
+            "false": "The current method has no exploitable security vulnerability.",
+            "true": "The current method has an exploitable security vulnerability.",
+        },
+    },
+}
+
+
+def context_text(row):
+    state = row["state"]
+    target = state.get("method") or {}
+
+    def neighbors(name):
+        chunks = []
+        for item in state.get(name, []):
+            if isinstance(item, str):
+                chunks.append(item)
+            else:
+                chunks.append(f"{item.get('name', '')} ({item.get('path', '')})\n{item.get('source', '')}")
+        return "\n".join(chunks)
+
+    sections = {
+        "method": f"LANGUAGE: {row.get('language') or 'unknown'}\nPATH: {target.get('path') or ''}"
+                  f"\nMETHOD: {target.get('name') or ''}\n{target.get('source') or row.get('source') or ''}",
+        "edges": "CALL GRAPH EDGES:\n" + "\n".join(map(str, state.get("call_graph", []))),
+        "callers": "CALLERS:\n" + neighbors("called_by"),
+        "callees": "CALLEES:\n" + neighbors("calls"),
+        "module": "MODULE SCOPE:\n" + str(state.get("module_scope", "")),
+        "imports": "IMPORTS:\n" + "\n".join(map(str, state.get("imports", []))),
+    }
+    order = ("imports", "module", "edges", "callers", "callees", "method")
+    return "\n\n".join(sections[key] for key in order if sections[key].strip())
+
+
+head_path = Path(os.getenv("CLM_HEAD") or hf_hub_download(
+    "Contrastive-LM/CLM-v0.1-8B", "CLM_v0.1-8B.pt"))
+expected_hash = "b2b4a8c9c2d39263eff78a351eb909a342ce9b3bf21a3f07c1d1bf15f1c4eda5"
+if hashlib.sha256(head_path.read_bytes()).hexdigest() != expected_hash:
+    raise RuntimeError("CLM choice head does not match the published checkpoint")
+
+device = torch.device("cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu")
+blob = torch.load(head_path, map_location="cpu", weights_only=True)
+cfg = blob["cfg"]
+kwargs = {"width": cfg["width"], "depth": cfg["depth"],
+          "proj": cfg.get("projection_dim", 512),
+          "activation": cfg.get("activation", "gelu"),
+          "layernorm": cfg.get("layernorm", False),
+          "residual": cfg.get("residual", False),
+          "hidden": cfg.get("hidden_size", 4096)}
+state_head = make_head(**kwargs).to(device).eval()
+action_head = make_head(**kwargs).to(device).eval()
+state_head.load_state_dict(blob["state_head"])
+action_head.load_state_dict(blob["action_head"])
+scale = torch.as_tensor(blob["logit_scale"], device=device).float().exp().clamp(max=100.0)
+
+model_name = "Qwen/Qwen3-8B"
+recipe = Recipe(model_name, 6144)
+backend = ServerBackend(os.getenv("CLM_EMBED_URL", "http://127.0.0.1:8090/v1/embeddings"),
+                        model_name, batch=16)
+candidate_vectors = {}
+
+
+def embed(ids):
+    # Upstream's embedding backend emits progress on stdout; reserve stdout for NDJSON.
+    with contextlib.redirect_stdout(sys.stderr):
+        vector = backend.embed([ids])[0]
+    return torch.from_numpy(np.asarray(vector, dtype=np.float16).astype(np.float32)).to(device)
+
+
+with torch.inference_mode():
+    for line in sys.stdin:
+        row = json.loads(line)
+        domain = row["domain"]
+        state_text, keys, candidates = build_pairs(context_text(row), {domain: QUESTIONS[domain]})[domain]
+        if keys != ["false", "true"] or len(candidates) != 2:
+            raise RuntimeError("CLM option order changed")
+        if domain not in candidate_vectors:
+            candidate_vectors[domain] = torch.stack([
+                embed(recipe.text_ids(text, keep="head")) for text in candidates])
+        state = embed(recipe.text_ids(state_text, keep="tail")).unsqueeze(0)
+        state_z = F.normalize(state_head(state), dim=-1)
+        action_z = F.normalize(action_head(candidate_vectors[domain]), dim=-1)
+        logits = scale * torch.einsum("bd,kd->bk", state_z, action_z)
+        score = torch.softmax(logits.float(), dim=-1)[0, 1].item()
+        print(json.dumps({"score": score}), flush=True)

adapters/jev_lite.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Persistent benchmark.py command adapter for the released jev-lite checkpoint."""
+
+import importlib.util
+import json
+import os
+from pathlib import Path
+import sys
+
+from huggingface_hub import snapshot_download
+from peft import PeftModel
+import torch
+from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+
+base_path = os.getenv("JEV_LITE_BASE") or snapshot_download(
+    "google/gemma-4-E4B-it", revision="ee0ef6023621cff504d758262d4e04895a5af4a2")
+adapter_path = os.getenv("JEV_LITE_ADAPTER") or snapshot_download(
+    "vagmi/jev-lite", revision="90b23bc26c53f5a897684456893b2b7edeb90297")
+spec = importlib.util.spec_from_file_location("jev_lite_primitives", Path(adapter_path) / "primitives.py")
+primitives = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(primitives)
+device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+tokenizer = AutoTokenizer.from_pretrained(adapter_path)
+base = AutoModelForImageTextToText.from_pretrained(
+    base_path, torch_dtype=torch.bfloat16,
+    attn_implementation="sdpa" if device == "cuda" else "eager",
+    low_cpu_mem_usage=True)
+model = PeftModel.from_pretrained(base, adapter_path).eval().to(device)
+letters = [tokenizer.encode(" " + c, add_special_tokens=False)[0]
+           for c in primitives.LETTERS[:2]]
+if len(set(letters)) != 2:
+    raise RuntimeError("Answer token IDs are not distinct")
+
+with torch.inference_mode():
+    for line in sys.stdin:
+        request = json.loads(line)
+        question = request["question"]
+        item = primitives.normalize({
+            "type": "noul", "state": json.dumps(request["state"], ensure_ascii=False),
+            "question": question["instructions"], "options": ["true", "false"],
+            "criteria": question["criteria"],
+        })
+        prompt = (primitives.PREFIX + item["state"] + "\n</state>\n\n"
+                  + primitives.question_block(item) + "\nAnswer:")
+        ids = [tokenizer.bos_token_id] + tokenizer.encode(prompt, add_special_tokens=False)
+        tensor = torch.tensor([ids], dtype=torch.long, device=device)
+        logits = model(input_ids=tensor).logits[0, -1].float()
+        score = torch.softmax(logits[letters], dim=-1)[0].item()
+        print(json.dumps({"score": score}), flush=True)

adapters/jevk5.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Persistent benchmark.py command adapter for the pinned, unmodified JevK5 v0.2.
+
+Install the upstream runtime from https://github.com/allebee/jevk5, then run
+with JEVK5_MODEL pointing to a local snapshot if it is already downloaded.
+"""
+
+import json
+import os
+import sys
+
+from huggingface_hub import snapshot_download
+from jevk5.runtime import JevK5
+
+
+REVISION = "3c673298eb7f2dc7cb98019262c55b1fac01a0bc"
+path = os.getenv("JEVK5_MODEL") or snapshot_download("alibiserikbay/JevK5", revision=REVISION)
+model = JevK5(path, graphs=False)
+if model.temperature != 1.532:
+    raise RuntimeError("This adapter expects the v0.2 checkpoint used in the published result")
+
+for line in sys.stdin:
+    row = json.loads(line)
+    probabilities, _ = model.probabilities(row["state"], row["question"])
+    print(json.dumps({"score": float(probabilities["true"])}), flush=True)

adapters/securebert.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Persistent benchmark.py adapter for Cisco's released SecureBERT detection head.
+
+The original benchmark run did not record the exact Hub snapshot revision.
+Set SECUREBERT_MODEL to that snapshot when reproducing a specific run.
+"""
+
+import json
+import math
+import os
+import sys
+
+from huggingface_hub import snapshot_download
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+
+CAPS = (("method", 2800), ("edges", 120), ("callers", 520),
+        ("callees", 520), ("module", 240), ("imports", 120))
+path = os.getenv("SECUREBERT_MODEL") or snapshot_download(
+    "cisco-ai/SecureBERT2.0-code-vuln-detection")
+tokenizer = AutoTokenizer.from_pretrained(path)
+model = AutoModelForSequenceClassification.from_pretrained(path, attn_implementation="sdpa")
+device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+model.to(device).eval()
+
+
+def sections(row):
+    state = row["state"]
+    method = state["method"]
+
+    def neighbors(key):
+        return "\n".join(f"{item.get('name', '')} ({item.get('path', '')})\n{item.get('source', '')}"
+                         for item in state.get(key, []))
+
+    return {
+        "method": f"LANGUAGE: {row['language']}\nPATH: {method.get('path', '')}"
+                  f"\nMETHOD: {method.get('name', '')}\n{method.get('source', '')}",
+        "edges": "CALL GRAPH EDGES:\n" + "\n".join(state.get("call_graph", [])),
+        "callers": "CALLERS:\n" + neighbors("called_by"),
+        "callees": "CALLEES:\n" + neighbors("calls"),
+        "module": "MODULE SCOPE:\n" + str(state.get("module_scope", "")),
+        "imports": "IMPORTS:\n" + "\n".join(map(str, state.get("imports", []))),
+    }
+
+
+with torch.inference_mode():
+    for line in sys.stdin:
+        row = json.loads(line)
+        if row["domain"] != "security":
+            raise ValueError("SecureBERT adapter supports security only")
+        parts = sections(row)
+        ids = [tokenizer.cls_token_id]
+        for name, cap in CAPS:
+            ids.extend(tokenizer.encode(parts[name], add_special_tokens=False)[:cap])
+        ids.append(tokenizer.sep_token_id)
+        if len(ids) > 4096:
+            ids = ids[:4095] + [tokenizer.sep_token_id]
+        length = math.ceil(len(ids) / 64) * 64
+        tokens = torch.full((1, length), tokenizer.pad_token_id, dtype=torch.long, device=device)
+        mask = torch.zeros_like(tokens)
+        tokens[0, :len(ids)] = torch.tensor(ids, dtype=torch.long, device=device)
+        mask[0, :len(ids)] = 1
+        hidden = model.model(input_ids=tokens, attention_mask=mask)[0]
+        if model.config.classifier_pooling == "mean":
+            m = mask.unsqueeze(-1)
+            pooled = (hidden * m).sum(1) / m.sum(1).clamp(min=1)
+        else:
+            pooled = hidden[:, 0]
+        logits = model.classifier(model.drop(model.head(pooled)))[0].float()
+        score = torch.sigmoid(logits[1] - logits[0]).item()
+        print(json.dumps({"score": score}), flush=True)

benchmark.py

@@ -213,6 +213,7 @@ def run(args: argparse.Namespace) -> None:
                     score = jev_score(state, args.domain, revision, args.api_url)
                 else:
                     request = {"domain": args.domain, "pair_id": pair["pair_id"], "role": role,
+                               "language": pair.get("language"), "source": pair[role]["source"],
                                "state": state, "question": QUESTION[args.domain]}
                     assert command and command.stdin and command.stdout
                     command.stdin.write(json.dumps(request, ensure_ascii=False) + "\n")