Update evaluation_harness.py

evaluation_harness.py

@@ -1,39 +1,60 @@
 #!/usr/bin/env python3
 """
-GCI-Bench harness: measures whether a small (1M-100M parameter) HuggingFace
-transformer's attention * gradient saliency prioritizes causally-relevant
-("related") sentences over same-domain "distractor" sentences mixed into the
-same context, and whether it links causally-connected sentences together.
+GCI-Bench harness (robust build)
+=================================
+Measures whether a small (1M-100M parameter) HuggingFace transformer's
+attention * gradient saliency prioritizes causally-relevant ("related")
+sentences over same-domain "distractor" sentences mixed into the same
+context, and whether it links causally-connected sentences together.
 
 This benchmark does NOT grade answer correctness. It only inspects internal
-attention/gradient dynamics, so it works with any small causal or masked
-language model that exposes `output_attentions`.
+attention/gradient dynamics.
+
+Design goals for this build:
+  * Works across CausalLM / MaskedLM / Seq2SeqLM architectures.
+  * Tries multiple attn_implementation values and falls back gracefully when
+    a custom architecture hard-errors on sdpa/flash_attention_2 (many do).
+  * Extracts attention tensors generically -- not just from `.attentions` --
+    so custom/trust_remote_code architectures with nonstandard output field
+    names still work if they expose *some* attention-shaped tensor.
+  * Normalizes arbitrary attention tensor dim orderings (batch/heads/seq_q/
+    seq_k in any order) instead of assuming a fixed layout.
+  * Falls back to an approximate char-offset reconstruction for tokenizers
+    that don't support `return_offsets_mapping` (some custom/slow
+    tokenizers).
+  * Never crashes the whole run on a single bad item/layer -- everything
+    that can fail is caught and turned into a clearly-labeled skip reason.
+
+Hard limitation that CANNOT be worked around: architectures whose attention
+is computed purely inside a fused, non-differentiable-wrt-weights kernel
+(e.g. some flash-attention-only custom code that never returns/retains
+attention *weights* as a tensor with a grad_fn) cannot be introspected by
+this technique at all. Those items/models will be skipped with reason
+"attentions_not_differentiable" or "no_attentions_returned".
 
 Usage:
-    python gci_bench.py --model roneneldan/TinyStories-33M --limit 500
-    python gci_bench.py --model prajjwal1/bert-tiny --limit 300
-    python gci_bench.py --model distilgpt2 --limit 1000 \
-        --submit-url https://your-deployment.example.com/api/leaderboard
-
-See README.md in this folder for a full explanation of the scoring formulas.
+    python evaluation_harness.py --model roneneldan/TinyStories-33M --limit 500
+    python evaluation_harness.py --model prajjwal1/bert-tiny --limit 300
+    python evaluation_harness.py --model distilgpt2 --limit 1000 \
+        --hub-model-repo distilbert/distilgpt2 --dataset-id your-org/gci-bench
 """
 
 from __future__ import annotations
 
 import argparse
+import datetime
 import json
 import os
 import random
 import sys
 import urllib.request
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Optional
 
 import numpy as np
-import pandas as pd
+import pandas as pd  # noqa: F401  (kept for parity / potential future use)
 import pyarrow.parquet as pq
 import torch
-import torch.nn.functional as F  # noqa: F401  (kept for clarity / potential extensions)
 
 try:
     from tqdm import tqdm
@@ -41,10 +62,10 @@ except ImportError:  # pragma: no cover - tqdm is a soft dependency
     def tqdm(iterable, **kwargs):
         return iterable
 
-
 from transformers import (
     AutoModelForCausalLM,
     AutoModelForMaskedLM,
+    AutoModelForSeq2SeqLM,
     AutoTokenizer,
 )
 
@@ -52,6 +73,18 @@ EPS = 1e-8
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 DEFAULT_DATASET = os.path.join(SCRIPT_DIR, "data", "test-00000-of-00001.parquet")
 
+MODEL_CLASSES: list[tuple[Any, str]] = [
+    (AutoModelForCausalLM, "causal"),
+    (AutoModelForMaskedLM, "mlm"),
+    (AutoModelForSeq2SeqLM, "seq2seq"),
+]
+
+# Tried in order. `None` means "don't pass attn_implementation at all, let
+# the library/custom code decide" -- necessary because some architectures
+# error out on an explicit "eager" string too (rare, but happens with some
+# trust_remote_code models that only recognize their own custom names).
+DEFAULT_ATTN_CANDIDATES: list[Optional[str]] = ["eager", None]
+
 
 # ---------------------------------------------------------------------------
 # Data loading
@@ -64,93 +97,156 @@ def load_dataset(path: str) -> list[dict]:
                 return [json.loads(line) for line in text.splitlines() if line.strip()]
             return json.loads(text)
 
-    # Parquet format (HuggingFace-compatible, preferred)
     if path.endswith(".parquet"):
         table = pq.read_table(path)
         df = table.to_pandas()
         items = []
         for _, row in df.iterrows():
             item = row.to_dict()
-            # Parse JSON-encoded nested fields back into objects
-            for field in ("segments", "relatedSegmentIds", "unrelatedSegmentIds", "keyLinkPairs", "meta"):
-                if isinstance(item.get(field), str):
-                    item[field] = json.loads(item[field])
+            for key in ("segments", "relatedSegmentIds", "unrelatedSegmentIds", "keyLinkPairs", "meta"):
+                if isinstance(item.get(key), str):
+                    item[key] = json.loads(item[key])
             items.append(item)
         return items
 
-    # JSONL format (legacy fallback)
     with open(path, "r", encoding="utf-8") as f:
         return [json.loads(line) for line in f if line.strip()]
 
 
 # ---------------------------------------------------------------------------
-# Model loading (tries CausalLM first, then MaskedLM)
+# Model loading -- robust to custom architectures / custom attention kernels
 # ---------------------------------------------------------------------------
 @dataclass
 class LoadedModel:
     tokenizer: Any
     model: Any
-    model_type: str  # "causal" | "mlm"
+    model_type: str  # "causal" | "mlm" | "seq2seq"
     num_params: int
     device: torch.device
+    attn_implementation: str
+    is_encoder_decoder: bool
+    fast_tokenizer: bool
 
 
-def load_model(model_name: str, device: torch.device, trust_remote_code: bool = False) -> LoadedModel:
+def _try_force_eager_post_load(model: Any) -> None:
+    """Best-effort: force a loaded model into eager attention mode even if
+    from_pretrained's attn_implementation kwarg was ignored (this happens
+    with some trust_remote_code custom architectures)."""
+    set_fn = getattr(model, "set_attn_implementation", None)
+    if callable(set_fn):
+        try:
+            set_fn("eager")
+            return
+        except Exception:
+            pass
+
+    cfg = getattr(model, "config", None)
+    if cfg is None:
+        return
+    for attr in ("_attn_implementation", "attn_implementation"):
+        try:
+            setattr(cfg, attr, "eager")
+        except Exception:
+            pass
+    # Multimodal / composite configs (per-backbone attn implementations).
+    for sub_name in getattr(cfg, "sub_configs", {}) or {}:
+        sub_cfg = getattr(cfg, sub_name, None)
+        if sub_cfg is not None:
+            try:
+                setattr(sub_cfg, "_attn_implementation", "eager")
+            except Exception:
+                pass
+    try:
+        cfg.output_attentions = True
+    except Exception:
+        pass
+
+
+def load_model(
+    model_name: str,
+    device: torch.device,
+    attn_candidates: list[Optional[str]],
+    dtype: Optional[str] = None,
+    trust_remote_code: bool = False,
+    revision: Optional[str] = None,
+) -> LoadedModel:
     trust_kwargs = {"trust_remote_code": True} if trust_remote_code else {}
+    rev_kwargs = {"revision": revision} if revision else {}
+
+    fast_tokenizer = True
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True, **trust_kwargs, **rev_kwargs)
+    except Exception:
+        tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False, **trust_kwargs, **rev_kwargs)
+        fast_tokenizer = False
+    if not getattr(tokenizer, "is_fast", False):
+        fast_tokenizer = False
 
-    tokenizer = AutoTokenizer.from_pretrained(
-        model_name, use_fast=True, **trust_kwargs
-    )
     if tokenizer.pad_token is None:
         if tokenizer.eos_token is not None:
             tokenizer.pad_token = tokenizer.eos_token
         else:
             tokenizer.add_special_tokens({"pad_token": "[PAD]"})
 
+    torch_dtype = getattr(torch, dtype, None) if dtype else None
+
     last_error: Optional[Exception] = None
-    for model_cls, model_type in ((AutoModelForCausalLM, "causal"), (AutoModelForMaskedLM, "mlm")):
-        try:
+    for model_cls, model_type in MODEL_CLASSES:
+        for attn_impl in attn_candidates:
+            kwargs: dict[str, Any] = dict(trust_kwargs)
+            kwargs.update(rev_kwargs)
+            if torch_dtype is not None:
+                kwargs["torch_dtype"] = torch_dtype
+            if attn_impl is not None:
+                kwargs["attn_implementation"] = attn_impl
             try:
-                model = model_cls.from_pretrained(
-                    model_name, attn_implementation="eager", **trust_kwargs
-                )
+                model = model_cls.from_pretrained(model_name, **kwargs)
             except TypeError:
-                # Older transformers versions don't accept attn_implementation.
-                model = model_cls.from_pretrained(model_name, **trust_kwargs)
+                # Older transformers / architecture doesn't accept this kwarg at all.
+                kwargs.pop("attn_implementation", None)
+                try:
+                    model = model_cls.from_pretrained(model_name, **kwargs)
+                except Exception as e:  # noqa: BLE001
+                    last_error = e
+                    continue
+            except ValueError as e:
+                # e.g. "<Arch> does not support an attention implementation
+                # through torch.nn.functional.scaled_dot_product_attention yet."
+                last_error = e
+                continue
+            except Exception as e:  # noqa: BLE001
+                last_error = e
+                continue
+
+            _try_force_eager_post_load(model)
             model.to(device)
             model.eval()
             num_params = sum(p.numel() for p in model.parameters())
-            return LoadedModel(tokenizer, model, model_type, num_params, device)
-        except Exception as e:  # noqa: BLE001 - we want to try the next model class
-            last_error = e
-            continue
+            resolved_impl = str(getattr(model.config, "_attn_implementation", attn_impl or "unknown"))
+            is_enc_dec = bool(getattr(model.config, "is_encoder_decoder", model_type == "seq2seq"))
+            return LoadedModel(
+                tokenizer=tokenizer,
+                model=model,
+                model_type=model_type,
+                num_params=num_params,
+                device=device,
+                attn_implementation=resolved_impl,
+                is_encoder_decoder=is_enc_dec,
+                fast_tokenizer=fast_tokenizer,
+            )
 
-    # If trust_remote_code=False failed with custom-code error, retry with trust_remote_code
     if not trust_remote_code and last_error and "trust_remote_code" in str(last_error).lower():
-        return load_model(model_name, device, trust_remote_code=True)
+        return load_model(model_name, device, attn_candidates, dtype, True, revision)
 
     raise RuntimeError(
-        f"Could not load '{model_name}' as AutoModelForCausalLM or AutoModelForMaskedLM: {last_error}"
+        f"Could not load '{model_name}' as CausalLM / MaskedLM / Seq2SeqLM with any of "
+        f"attn_implementation in {attn_candidates}: {last_error}"
     )
 
 
 # ---------------------------------------------------------------------------
-# Saliency computation for a single item
+# Offset mapping (with fallback for slow / custom tokenizers)
 # ---------------------------------------------------------------------------
-@dataclass
-class ItemResult:
-    id: str
-    topic: str
-    difficulty: str
-    num_tokens: int
-    priority_score: float
-    linkage_score: Optional[float]
-    related_mean: float
-    unrelated_mean: float
-    skipped: bool = False
-    reason: str = ""
-
-
 def char_span_to_token_indices(offsets: list[tuple[int, int]], char_start: int, char_end: int) -> list[int]:
     idxs = []
     for i, (s, e) in enumerate(offsets):
@@ -161,21 +257,165 @@ def char_span_to_token_indices(offsets: list[tuple[int, int]], char_start: int,
     return idxs
 
 
-def compute_saliency_matrix(attentions) -> np.ndarray:
-    """Sum_layers Sum_heads |A * dL/dA| -> (seq, seq) numpy matrix."""
-    seq_len = attentions[0].shape[-1]
+def approx_offsets_from_slow_tokenizer(
+    tokenizer: Any, text: str, input_ids: torch.Tensor
+) -> list[tuple[int, int]]:
+    """Best-effort char-offset reconstruction for tokenizers that don't
+    support `return_offsets_mapping` (slow / custom tokenizers). Walks
+    through the decoded pieces and locates them in `text` sequentially.
+    This is approximate -- it can misalign on tokenizers with heavy
+    normalization (e.g. lowercasing, accent stripping) -- but degrades
+    gracefully to a (0, 0) "unknown span" per unmatched token rather than
+    crashing.
+    """
+    offsets: list[tuple[int, int]] = []
+    cursor = 0
+    special_ids = set(getattr(tokenizer, "all_special_ids", []) or [])
+    for tok_id in input_ids[0].tolist():
+        if tok_id in special_ids:
+            offsets.append((0, 0))
+            continue
+        piece = tokenizer.decode([tok_id], skip_special_tokens=False, clean_up_tokenization_spaces=False)
+        stripped = piece.strip()
+        if not stripped:
+            offsets.append((0, 0))
+            continue
+        pos = text.find(stripped, cursor)
+        if pos == -1:
+            pos = text.find(stripped)
+        if pos == -1:
+            offsets.append((0, 0))
+            continue
+        start, end = pos, pos + len(stripped)
+        offsets.append((start, end))
+        cursor = end
+    return offsets
+
+
+# ---------------------------------------------------------------------------
+# Generic attention extraction + shape normalization
+# ---------------------------------------------------------------------------
+def extract_raw_attentions(outputs: Any, prefer_fields: tuple[str, ...] = ()) -> list[torch.Tensor]:
+    """Pull every self-attention weight tensor out of a HF ModelOutput,
+    regardless of model family / custom architecture field naming."""
+    found: list[torch.Tensor] = []
+    seen_ids: set[int] = set()
+
+    def add(t: Any) -> None:
+        if torch.is_tensor(t) and id(t) not in seen_ids:
+            seen_ids.add(id(t))
+            found.append(t)
+
+    ordered_fields = tuple(prefer_fields) + ("attentions", "decoder_attentions", "encoder_attentions", "cross_attentions")
+    for field_name in ordered_fields:
+        val = getattr(outputs, field_name, None)
+        if val:
+            for t in val:
+                add(t)
+        if found:
+            return found
+
+    # Generic fallback: scan every output field whose name mentions attention,
+    # for custom architectures using nonstandard field names.
+    keys = list(outputs.keys()) if hasattr(outputs, "keys") else [
+        k for k in vars(outputs) if not k.startswith("_")
+    ]
+    for k in keys:
+        kl = str(k).lower()
+        if "attn" not in kl and "attention" not in kl:
+            continue
+        val = getattr(outputs, k, None)
+        if val is None:
+            continue
+        items = val if isinstance(val, (tuple, list)) else [val]
+        for t in items:
+            add(t)
+    return found
+
+
+def normalize_attn_and_grad(
+    attn: torch.Tensor, grad: Optional[torch.Tensor], seq_len: int
+) -> tuple[Optional[torch.Tensor], Optional[torch.Tensor]]:
+    """Best-effort reshape of an arbitrarily-ordered attention tensor (and its
+    gradient, if present) into (heads, seq_len, seq_len). Handles models whose
+    attention weights aren't laid out as the conventional
+    (batch, heads, seq_q, seq_k) -- e.g. (batch, seq_q, seq_k, heads), grouped
+    query-attention variants, or single-head models with the head dim
+    squeezed out. Returns (None, None) if the shape can't be safely
+    disambiguated.
+    """
+    if attn is None or attn.dim() < 2:
+        return None, None
+    shape = list(attn.shape)
+    seq_dims = [i for i, s in enumerate(shape) if s == seq_len]
+    if len(seq_dims) < 2:
+        return None, None  # can't identify query/key dims with confidence
+    key_dim, query_dim = seq_dims[-1], seq_dims[-2]
+    other_dims = [i for i in range(attn.dim()) if i not in (query_dim, key_dim)]
+    batch_dim = next((i for i in other_dims if shape[i] == 1), other_dims[0] if other_dims else None)
+    head_dims = [i for i in other_dims if i != batch_dim]
+    perm = ([batch_dim] if batch_dim is not None else []) + head_dims + [query_dim, key_dim]
+
+    def _reshape(t: torch.Tensor) -> torch.Tensor:
+        tp = t.permute(*perm)
+        if batch_dim is not None:
+            tp = tp[0]
+        return tp.reshape(-1, seq_len, seq_len)
+
+    try:
+        attn_r = _reshape(attn)
+        grad_r = _reshape(grad) if grad is not None else None
+    except Exception:
+        return None, None
+    return attn_r, grad_r
+
+
+def compute_saliency_matrix(
+    grad_capable_attentions: list[torch.Tensor], seq_len: int
+) -> tuple[np.ndarray, int, int]:
+    """Sum_layers Sum_heads |A * dL/dA| -> (seq, seq) numpy matrix.
+    Returns (matrix, n_layers_used, n_layers_skipped)."""
     saliency = torch.zeros((seq_len, seq_len), dtype=torch.float32)
-    for attn in attentions:
+    used, skipped = 0, 0
+    for attn in grad_capable_attentions:
         grad = attn.grad
         if grad is None:
+            skipped += 1
+            continue
+        attn_n, grad_n = normalize_attn_and_grad(attn, grad, seq_len)
+        if attn_n is None or grad_n is None:
+            skipped += 1
             continue
-        # attn, grad: (1, heads, seq, seq)
-        contrib = (attn[0].detach() * grad[0].detach()).abs().sum(dim=0)  # (seq, seq)
-        saliency += contrib.cpu()
-    return saliency.numpy()
+        contrib = (attn_n.detach() * grad_n.detach()).abs().sum(dim=0)  # (seq, seq)
+        saliency += contrib.to(dtype=torch.float32, device="cpu")
+        used += 1
+    return saliency.numpy(), used, skipped
+
+
+# ---------------------------------------------------------------------------
+# Per-item scoring
+# ---------------------------------------------------------------------------
+@dataclass
+class ItemResult:
+    id: str
+    topic: str
+    difficulty: str
+    num_tokens: int
+    priority_score: float
+    linkage_score: Optional[float]
+    related_mean: float
+    unrelated_mean: float
+    skipped: bool = False
+    reason: str = ""
 
 
-def run_item(loaded: LoadedModel, item: dict, max_length: int, mask_ratio: float, rng: random.Random) -> ItemResult:
+def _skip(item: dict, seq_len: int, reason: str) -> ItemResult:
+    return ItemResult(item["id"], item["topic"], item["difficulty"], seq_len, 0.0, None, 0.0, 0.0, True, reason)
+
+
+def run_item(
+    loaded: LoadedModel, item: dict, max_length: int, mask_ratio: float, rng: random.Random
+) -> ItemResult:
     tokenizer, model, model_type, device = (
         loaded.tokenizer,
         loaded.model,
@@ -187,64 +427,99 @@ def run_item(loaded: LoadedModel, item: dict, max_length: int, mask_ratio: float
     question = item["question"]
     full_text = f"{context} {question}"
 
-    enc = tokenizer(
-        full_text,
-        return_offsets_mapping=True,
-        return_tensors="pt",
-        truncation=True,
-        max_length=max_length,
-    )
-    offsets = enc.pop("offset_mapping")[0].tolist()
+    offsets: Optional[list[tuple[int, int]]] = None
+    try:
+        enc = tokenizer(
+            full_text,
+            return_offsets_mapping=True,
+            return_tensors="pt",
+            truncation=True,
+            max_length=max_length,
+        )
+        offsets = enc.pop("offset_mapping")[0].tolist()
+    except Exception:
+        # Slow / custom tokenizer without fast-tokenizer offset support.
+        enc = tokenizer(full_text, return_tensors="pt", truncation=True, max_length=max_length)
+
     input_ids = enc["input_ids"].to(device)
     attention_mask = enc.get("attention_mask")
     if attention_mask is not None:
         attention_mask = attention_mask.to(device)
 
+    if offsets is None:
+        offsets = approx_offsets_from_slow_tokenizer(tokenizer, full_text, enc["input_ids"])
+
     seq_len = input_ids.shape[1]
     if seq_len < 4:
-        return ItemResult(item["id"], item["topic"], item["difficulty"], seq_len, 0, None, 0, 0, True, "too_short")
+        return _skip(item, seq_len, "too_short")
 
     model.zero_grad(set_to_none=True)
 
-    if model_type == "causal":
-        outputs = model(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            labels=input_ids,
-            output_attentions=True,
-        )
-        loss = outputs.loss
-        attentions = outputs.attentions
-    else:
-        mask_token_id = tokenizer.mask_token_id
-        if mask_token_id is None:
-            return ItemResult(item["id"], item["topic"], item["difficulty"], seq_len, 0, None, 0, 0, True, "no_mask_token")
-        maskable = [i for i, (s, e) in enumerate(offsets) if not (s == 0 and e == 0)]
-        n_mask = max(1, int(len(maskable) * mask_ratio))
-        masked_positions = rng.sample(maskable, min(n_mask, len(maskable)))
-        masked_input_ids = input_ids.clone()
-        labels = torch.full_like(input_ids, -100)
-        for pos in masked_positions:
-            labels[0, pos] = input_ids[0, pos]
-            masked_input_ids[0, pos] = mask_token_id
-        outputs = model(
-            input_ids=masked_input_ids,
-            attention_mask=attention_mask,
-            labels=labels,
-            output_attentions=True,
-        )
-        loss = outputs.loss
-        attentions = outputs.attentions
+    prefer_fields: tuple[str, ...] = ()
+    try:
+        if model_type == "causal":
+            outputs = model(
+                input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, output_attentions=True
+            )
+            loss = outputs.loss
+        elif model_type == "seq2seq":
+            outputs = model(
+                input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, output_attentions=True
+            )
+            loss = outputs.loss
+            # Segments describe the *input* context, so score encoder self-attention.
+            prefer_fields = ("encoder_attentions",)
+        else:  # mlm
+            mask_token_id = tokenizer.mask_token_id
+            if mask_token_id is None:
+                return _skip(item, seq_len, "no_mask_token")
+            maskable = [i for i, (s, e) in enumerate(offsets) if not (s == 0 and e == 0)]
+            if not maskable:
+                return _skip(item, seq_len, "no_maskable_tokens")
+            n_mask = max(1, int(len(maskable) * mask_ratio))
+            masked_positions = rng.sample(maskable, min(n_mask, len(maskable)))
+            masked_input_ids = input_ids.clone()
+            labels = torch.full_like(input_ids, -100)
+            for pos in masked_positions:
+                labels[0, pos] = input_ids[0, pos]
+                masked_input_ids[0, pos] = mask_token_id
+            outputs = model(
+                input_ids=masked_input_ids, attention_mask=attention_mask, labels=labels, output_attentions=True
+            )
+            loss = outputs.loss
+    except Exception as e:  # noqa: BLE001 - never crash the whole run on one item
+        return _skip(item, seq_len, f"forward_error:{type(e).__name__}:{e}")
 
     if loss is None or not torch.isfinite(loss):
-        return ItemResult(item["id"], item["topic"], item["difficulty"], seq_len, 0, None, 0, 0, True, "bad_loss")
+        return _skip(item, seq_len, "bad_loss")
+
+    raw_attentions = extract_raw_attentions(outputs, prefer_fields=prefer_fields)
+    if not raw_attentions:
+        return _skip(item, seq_len, "no_attentions_returned")
 
-    for attn in attentions:
-        attn.retain_grad()
+    grad_capable: list[torch.Tensor] = []
+    for attn in raw_attentions:
+        if torch.is_tensor(attn) and attn.requires_grad:
+            try:
+                attn.retain_grad()
+                grad_capable.append(attn)
+            except Exception:
+                pass
+
+    if not grad_capable:
+        # Architecture computed attentions but they're detached / non-differentiable
+        # w.r.t. the loss (common with some fused / custom kernels).
+        return _skip(item, seq_len, "attentions_not_differentiable")
+
+    try:
+        loss.backward()
+    except Exception as e:  # noqa: BLE001
+        return _skip(item, seq_len, f"backward_error:{type(e).__name__}:{e}")
 
-    loss.backward()
+    saliency, n_used, n_skipped_layers = compute_saliency_matrix(grad_capable, seq_len)
+    if n_used == 0 or saliency.sum() <= 0:
+        return _skip(item, seq_len, "zero_saliency")
 
-    saliency = compute_saliency_matrix(attentions)  # (seq, seq)
     token_importance = saliency.sum(axis=0)  # per key-token, summed over queries
 
     segments = item["segments"]
@@ -260,15 +535,12 @@ def run_item(loaded: LoadedModel, item: dict, max_length: int, mask_ratio: float
     unrelated_tokens = sorted({t for sid in unrelated_ids for t in seg_token_idxs.get(sid, [])})
 
     if not related_tokens or not unrelated_tokens:
-        return ItemResult(item["id"], item["topic"], item["difficulty"], seq_len, 0, None, 0, 0, True, "empty_segment_tokens")
+        return _skip(item, seq_len, "empty_segment_tokens")
 
     related_mean = float(token_importance[related_tokens].mean())
     unrelated_mean = float(token_importance[unrelated_tokens].mean())
     priority_score = 100.0 * related_mean / (related_mean + unrelated_mean + EPS)
 
-    # Linkage: for each causally-linked pair of related segments, compare the
-    # attention*gradient mass exchanged between them against a control baseline
-    # of mass exchanged between related content and unrelated (distractor) content.
     pair_scores = []
     for a, b in item.get("keyLinkPairs", []):
         idx_a = seg_token_idxs.get(a, [])
@@ -298,6 +570,60 @@ def run_item(loaded: LoadedModel, item: dict, max_length: int, mask_ratio: float
     )
 
 
+# ---------------------------------------------------------------------------
+# Hub submission (.eval_results/*.yaml PR)
+# ---------------------------------------------------------------------------
+def submit_to_hub(
+    summary: dict,
+    model_repo: str,
+    dataset_id: str,
+    task_id: str,
+    notes: Optional[str],
+    create_pr: bool,
+    revision: Optional[str],
+    source_url: str,
+) -> None:
+    try:
+        from huggingface_hub import HfApi
+        import yaml
+    except ImportError as e:
+        raise RuntimeError(
+            "Submitting to the Hub requires `huggingface_hub` and `pyyaml`. "
+            "Install with: pip install huggingface_hub pyyaml"
+        ) from e
+
+    entry = [
+        {
+            "dataset": {"id": dataset_id, "task_id": task_id},
+            "value": round(float(summary["gciScore"]), 3),
+            "date": summary["date"],
+            "source": {
+                "url": source_url,
+                "name": "GCI-Bench harness",
+            },
+            "notes": notes
+            or (
+                f"priorityScore={summary['priorityScore']}, "
+                f"linkageScore={summary['linkageScore']}, "
+                f"n={summary['numQuestions']}, skipped={summary['numSkipped']}"
+            ),
+        }
+    ]
+    yaml_str = yaml.safe_dump(entry, sort_keys=False)
+
+    api = HfApi()
+    result = api.upload_file(
+        path_or_fileobj=yaml_str.encode("utf-8"),
+        path_in_repo=".eval_results/gci-bench.yaml",
+        repo_id=model_repo,
+        repo_type="model",
+        revision=revision,
+        create_pr=create_pr,
+        commit_message="Add GCI-Bench evaluation result",
+    )
+    print(f"\nSubmitted to Hub: {result}")
+
+
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -305,15 +631,28 @@ def main():
     parser = argparse.ArgumentParser(description="GCI-Bench harness for small HuggingFace transformers.")
     parser.add_argument("--model", required=True, help="HuggingFace model id or local path (should be <=~100M params).")
     parser.add_argument("--dataset", default=DEFAULT_DATASET, help="Path or URL to gci-bench .parquet or .jsonl.")
-    parser.add_argument("--limit", type=int, default=500, help="Number of questions to sample (0 = all 5000).")
+    parser.add_argument("--limit", type=int, default=500, help="Number of questions to sample (0 = all).")
     parser.add_argument("--topic", default=None, help="Only evaluate a single topic id (e.g. 'cooking').")
     parser.add_argument("--max-length", type=int, default=256, help="Max token length per item.")
     parser.add_argument("--mask-ratio", type=float, default=0.15, help="Mask ratio used for MLM-style models.")
     parser.add_argument("--seed", type=int, default=42)
     parser.add_argument("--device", default=None, help="cpu | cuda | mps (default: auto-detect).")
+    parser.add_argument(
+        "--attn-implementation",
+        default="eager,auto",
+        help="Comma-separated list of attn_implementation values to try, in order. "
+        "'auto' means 'let the library decide' (no kwarg passed). Default: 'eager,auto'.",
+    )
+    parser.add_argument("--dtype", default=None, help="e.g. float32, float16, bfloat16 (default: model default).")
+    parser.add_argument("--trust-remote-code", action="store_true", help="Force trust_remote_code=True.")
+    parser.add_argument("--revision", default=None, help="Model revision (branch/tag/commit) to load.")
     parser.add_argument("--output", default=None, help="Where to write the full JSON results.")
-    parser.add_argument("--submit-url", default=None, help="POST the summary to a GCI-Bench dashboard's /api/leaderboard.")
-    parser.add_argument("--notes", default=None, help="Free-text note to attach to a leaderboard submission.")
+    parser.add_argument("--hub-model-repo", default=None, help="Model repo id to submit results to, e.g. 'org/model-name'.")
+    parser.add_argument("--dataset-id", default=None, help="Registered GCI-Bench Benchmark dataset id, e.g. 'your-org/gci-bench'.")
+    parser.add_argument("--task-id", default="default", help="Task id within the benchmark's eval.yaml.")
+    parser.add_argument("--source-url", default="https://github.com/YOUR_ORG/gci-bench", help="Link attached to the submitted result.")
+    parser.add_argument("--no-create-pr", action="store_true", help="Push directly instead of opening a PR (requires write access).")
+    parser.add_argument("--notes", default=None, help="Free-text note to attach to a Hub submission.")
     args = parser.parse_args()
 
     random.seed(args.seed)
@@ -330,35 +669,75 @@ def main():
     else:
         device = torch.device("cpu")
 
+    attn_candidates: list[Optional[str]] = [
+        None if tok.strip().lower() == "auto" else tok.strip()
+        for tok in args.attn_implementation.split(",")
+        if tok.strip()
+    ] or DEFAULT_ATTN_CANDIDATES
+
     print(f"Loading dataset from {args.dataset} ...")
     items = load_dataset(args.dataset)
     if args.topic:
         items = [it for it in items if it["topic"] == args.topic]
     print(f"Loaded {len(items)} items.")
 
-    if args.limit and args.limit > 0 and args.limit < len(items):
+    if args.limit and 0 < args.limit < len(items):
         items = rng.sample(items, args.limit)
     print(f"Evaluating {len(items)} items.")
 
-    print(f"Loading model '{args.model}' on {device} ...")
-    loaded = load_model(args.model, device)
-    print(f"Model type: {loaded.model_type} | Params: {loaded.num_params:,}")
+    print(f"Loading model '{args.model}' on {device} (attn candidates: {attn_candidates}) ...")
+    loaded = load_model(
+        args.model,
+        device,
+        attn_candidates,
+        dtype=args.dtype,
+        trust_remote_code=args.trust_remote_code,
+        revision=args.revision,
+    )
+    print(
+        f"Model type: {loaded.model_type} | Params: {loaded.num_params:,} | "
+        f"Resolved attn_implementation: {loaded.attn_implementation} | "
+        f"Fast tokenizer: {loaded.fast_tokenizer}"
+    )
     if loaded.num_params > 100_000_000:
         print(
             f"WARNING: model has {loaded.num_params/1e6:.1f}M parameters, which is above the "
             "intended <=100M range for GCI-Bench. Results are still computed, but keep this in mind."
         )
+    if loaded.attn_implementation not in ("eager",):
+        print(
+            f"NOTE: resolved attn_implementation is '{loaded.attn_implementation}', not 'eager'. "
+            "If this architecture doesn't return real (differentiable) attention weights under "
+            "this implementation, most/all items will be skipped with reason "
+            "'no_attentions_returned' or 'attentions_not_differentiable'."
+        )
 
     results: list[ItemResult] = []
     for item in tqdm(items, desc="Scoring"):
         try:
             res = run_item(loaded, item, args.max_length, args.mask_ratio, rng)
         except Exception as e:  # noqa: BLE001 - keep going on isolated failures
-            res = ItemResult(item["id"], item["topic"], item["difficulty"], 0, 0, None, 0, 0, True, f"error:{e}")
+            res = _skip(item, 0, f"error:{type(e).__name__}:{e}")
         results.append(res)
 
     valid = [r for r in results if not r.skipped]
     skipped = len(results) - len(valid)
+
+    if skipped:
+        reason_counts: dict[str, int] = {}
+        for r in results:
+            if r.skipped:
+                key = r.reason.split(":")[0]
+                reason_counts[key] = reason_counts.get(key, 0) + 1
+        print(f"\n{skipped}/{len(results)} items skipped. Breakdown: {json.dumps(reason_counts, indent=2)}")
+        if reason_counts.get("attentions_not_differentiable", 0) + reason_counts.get("no_attentions_returned", 0) > len(results) * 0.5:
+            print(
+                "WARNING: this model/architecture appears to not expose differentiable attention "
+                "weights under any tried attn_implementation. This is an issue of "
+                "some fused/flash-attention-only custom kernels, not a bug in this harness. "
+                "GCI-Bench cannot meaningfully score this model. Please open a community discussion."
+            )
+
     if not valid:
         print("No valid items were scored. Aborting.")
         sys.exit(1)
@@ -382,6 +761,7 @@ def main():
         "modelName": args.model,
         "numParams": int(loaded.num_params),
         "modelType": loaded.model_type,
+        "attnImplementation": loaded.attn_implementation,
         "numQuestions": len(valid),
         "numSkipped": skipped,
         "priorityScore": round(priority_score, 3),
@@ -389,11 +769,12 @@ def main():
         "gciScore": round(gci_score, 3),
         "priorityByTopic": by_topic_avg,
         "priorityByDifficulty": by_difficulty_avg,
+        "date": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
         "notes": args.notes,
     }
 
     print("\n=== GCI-Bench summary ===")
-    print(json.dumps({k: v for k, v in summary.items() if k not in ("priorityByTopic",)}, indent=2))
+    print(json.dumps({k: v for k, v in summary.items() if k != "priorityByTopic"}, indent=2))
 
     full_output = {
         "summary": summary,
@@ -405,21 +786,24 @@ def main():
             json.dump(full_output, f, indent=2)
         print(f"\nWrote full results to {args.output}")
 
-    if args.submit_url:
-        payload = dict(summary)
-        payload["raw"] = full_output["summary"]
-        req = urllib.request.Request(
-            args.submit_url,
-            data=json.dumps(payload).encode("utf-8"),
-            headers={"Content-Type": "application/json"},
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(req) as resp:
-                print(f"\nSubmitted to leaderboard: HTTP {resp.status}")
-        except Exception as e:  # noqa: BLE001
-            print(f"\nFailed to submit to leaderboard: {e}")
+    if args.hub_model_repo:
+        if not args.dataset_id:
+            print("\nSkipping Hub submission: --dataset-id is required (the registered GCI-Bench Benchmark dataset id).")
+        else:
+            try:
+                submit_to_hub(
+                    summary,
+                    model_repo=args.hub_model_repo,
+                    dataset_id=args.dataset_id,
+                    task_id=args.task_id,
+                    notes=args.notes,
+                    create_pr=not args.no_create_pr,
+                    revision=None,
+                    source_url=args.source_url,
+                )
+            except Exception as e:  # noqa: BLE001
+                print(f"\nFailed to submit to Hub: {e}")
 
 
 if __name__ == "__main__":
-    main()
+    main()