Sync evaluate.py with repo (reasoning-model + stratified easy/hard fixes)

evaluate.py

@@ -5,13 +5,16 @@ Reports exact-match accuracy plus micro/macro multi-label F1, stratified into
 "easy" (the weakness is named in the description) vs "hard" (it must be inferred),
 so you see real-world performance instead of one flattered average.
 
-Run it in an environment that has the model's deps (the Unsloth Studio venv is
-easiest, since it already has a torch/transformers new enough for gemma-4-E4B):
+Loads with plain transformers. Newer architectures (e.g. model_type ``gemma4``,
+used by gemma-4-E4B) need **transformers >= 5.5** -- older versions raise
+``KeyError: 'gemma4'``. Note: do NOT load gemma4 through unsloth in a Studio env
+whose transformers was upgraded -- the upgrade pulls ``huggingface_hub`` 1.x,
+which breaks ``unsloth_zoo``'s config lookup. Plain transformers is the clean path.
 
+    python evaluate.py --model "C:\\path\\to\\exported\\merged_model" --limit 500
     python evaluate.py --model "C:\\path\\to\\exported\\merged_model"
-    python evaluate.py --model eiphuggincve/your-model-repo --limit 500   # quick check
 
-Needs: torch, transformers, datasets, accelerate.
+Needs: transformers>=5.5, torch, datasets, accelerate.
 """
 
 from __future__ import annotations
@@ -21,11 +24,14 @@ import re
 
 import torch
 from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 CWE_RE = re.compile(r"CWE-\d+")
 
-# Same keyword list used to measure the dataset: a row is "easy" if the
-# description literally names the weakness, so the model can keyword-match.
+# A row is "easy" if the description literally names the weakness (the model can
+# keyword-match); "hard" rows require inferring the CWE from the prose.
+# NOTE: kept identical to eip_hf.normalize.EASY_KW (the cap uses it to retain hard
+# rows). If you change one, change the other -- tests/test_export.py guards this.
 EASY_KW = [
     "sql injection",
     "cross-site scripting",
@@ -50,12 +56,16 @@ EASY_KW = [
 
 
 def parse_cwes(text: str) -> set[str]:
+    # If a reasoning block leaked through (model ignored enable_thinking=False),
+    # keep only the text after the final </think> so CWEs mused about mid-thought
+    # don't count as predictions.
+    if "</think>" in text:
+        text = text.rsplit("</think>", 1)[1]
     return set(CWE_RE.findall(text))
 
 
 def is_easy(description: str) -> bool:
-    d = description.lower()
-    return any(k in d for k in EASY_KW)
+    return any(k in description.lower() for k in EASY_KW)
 
 
 def prf(tp: int, fp: int, fn: int) -> tuple[float, float, float]:
@@ -66,17 +76,29 @@ def prf(tp: int, fp: int, fn: int) -> tuple[float, float, float]:
 
 
 def build_prompt(tok, messages: list[dict]) -> str:
-    """Prompt = everything up to (but not including) the assistant answer."""
+    """Prompt = everything up to (but not including) the assistant answer.
+
+    For reasoning models (Qwen3.x, etc.) we pass ``enable_thinking=False``: this
+    is a single-label classification task, so the chain-of-thought only burns the
+    generation budget before the answer and pollutes parsing with CWEs mentioned
+    mid-reasoning. Templates that don't accept the kwarg ignore it via the retry.
+    """
     convo = messages[:-1]
-    try:
-        return tok.apply_chat_template(convo, tokenize=False, add_generation_prompt=True)
-    except Exception:
-        # Some chat templates (e.g. Gemma) reject a separate "system" role;
-        # fold the system text into the user turn instead.
-        sys_txt = next((m["content"] for m in convo if m["role"] == "system"), "")
-        usr_txt = next((m["content"] for m in convo if m["role"] == "user"), "")
-        folded = [{"role": "user", "content": f"{sys_txt}\n\n{usr_txt}".strip()}]
-        return tok.apply_chat_template(folded, tokenize=False, add_generation_prompt=True)
+    for kwargs in ({"enable_thinking": False}, {}):
+        try:
+            return tok.apply_chat_template(
+                convo, tokenize=False, add_generation_prompt=True, **kwargs
+            )
+        except TypeError:
+            continue  # template rejects enable_thinking -> retry without it
+        except Exception:
+            break  # some other template issue (e.g. no system role) -> fold below
+    # Some chat templates (e.g. Gemma) reject a separate "system" role;
+    # fold the system text into the user turn instead.
+    sys_txt = next((m["content"] for m in convo if m["role"] == "system"), "")
+    usr_txt = next((m["content"] for m in convo if m["role"] == "user"), "")
+    folded = [{"role": "user", "content": f"{sys_txt}\n\n{usr_txt}".strip()}]
+    return tok.apply_chat_template(folded, tokenize=False, add_generation_prompt=True)
 
 
 def score(truths: list[set[str]], preds: list[set[str]], easies: list[bool]) -> None:
@@ -126,38 +148,36 @@ def score(truths: list[set[str]], preds: list[set[str]], easies: list[bool]) ->
 def main() -> None:
     ap = argparse.ArgumentParser(description="Evaluate a CVE->CWE model on the test split.")
     ap.add_argument("--model", required=True, help="path or HF id of the fine-tuned (merged) model")
-    ap.add_argument("--dataset", default="eiphuggincve/cve-cwe-consensus")
+    ap.add_argument("--dataset", default="exploitintel/cve-cwe-consensus")
     ap.add_argument("--split", default="test")
     ap.add_argument(
         "--limit", type=int, default=None, help="evaluate only the first N rows (quick check)"
     )
     ap.add_argument("--batch-size", type=int, default=16)
-    ap.add_argument("--max-new-tokens", type=int, default=32)
+    # 256, not 32: reasoning models (Qwen3.x) may emit <think>...</think> even with
+    # enable_thinking=False if they were fine-tuned to reason. Greedy generation stops
+    # at EOS as soon as a bare answer finishes, so this only costs time on rows that
+    # actually think; the </think> strip in parse_cwes then recovers the answer.
+    ap.add_argument("--max-new-tokens", type=int, default=256)
     args = ap.parse_args()
 
     print(f"loading model: {args.model}")
-    # gemma-4-E4B has model_type 'gemma4', which stock transformers does not recognize
-    # (KeyError: 'gemma4') -- only unsloth's patched stack runs it, so load via unsloth.
-    try:
-        from unsloth import FastModel as Loader
-    except ImportError:
-        from unsloth import FastLanguageModel as Loader
-    model, tok = Loader.from_pretrained(
-        model_name=args.model,
-        max_seq_length=1024,
-        dtype=None,
-        load_in_4bit=False,  # set True if you hit out-of-memory
-    )
-    tok = getattr(tok, "tokenizer", tok)  # FastModel may return a processor wrapping the tokenizer
     try:
-        Loader.for_inference(model)  # 2x faster inference; no-op on some versions
-    except Exception:
-        pass
-    model.eval()
+        tok = AutoTokenizer.from_pretrained(args.model)
+    except (AttributeError, TypeError):
+        # Some Gemma tokenizer configs store `extra_special_tokens` as a list, which
+        # trips a transformers bug ('list' object has no attribute 'keys').
+        tok = AutoTokenizer.from_pretrained(args.model, extra_special_tokens={})
     tok.padding_side = "left"  # decoder-only batched generation needs left padding
     if tok.pad_token is None:
         tok.pad_token = tok.eos_token
-    device = model.device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    try:
+        model = AutoModelForCausalLM.from_pretrained(args.model, dtype="auto").to(device)
+    except TypeError:
+        # `dtype` is the transformers 5.x name; older releases use `torch_dtype`.
+        model = AutoModelForCausalLM.from_pretrained(args.model, torch_dtype="auto").to(device)
+    model.eval()
 
     ds = load_dataset(args.dataset, split=args.split)
     if args.limit: