Bound best-of fallback; figure-caption prompt rule; VLM loop-collapse scrub

Three general improvements to the LightOnOCR pipeline, validated on the full 20:
- Best-of fallback bound: only spend the penalty-free fallback generation when
  it could plausibly win (retry ran away, or dropped 2+ source headers). A clean
  retry covering all-but-one header is kept as-is. Cuts a doomed fallback on
  already-recovered runaways (5128504 1287s -> 581s) with no outcome change.
- EXTRACTION_PROMPT: figure captions take the poster's "Figure N:" line, not the
  Markdown image auto-description; never write the bracketed alt-text into a
  caption or section. General rule for all figures. Recovers AISec rougeL
  0.70 -> 0.92.
- vlm_scrub._collapse_loops: collapse a VLM decode runaway (a short token/line
  repeated >5x) to one instance before the other passes. O(n), fires only on
  pathological repetition; touched only isporeu of 19 caches (33316 -> 12791
  chars, KBA x4109 -> x4), the rest byte-stable.

Full-20 LightOnOCR (ranks 1-4): rougeL 0.792 -> 0.830 (now BEATS pdfplumber
0.819), field_proportion 0.856 -> 0.939, pass 13 -> 15/20. Known: rank-3 caption
extraction inflates 4552067 field_proportion to 1.58 (content fine, rougeL 0.81);
refinement pending.

Author: jimnoneill

calibration/vlm/vlm_scrub.py

@@ -169,9 +169,50 @@ def _strip_scaffold(text: str) -> str:
                      if not (ln.strip() and _SCAFFOLD_LABEL.match(ln.strip())))
 
 
+def _collapse_loops(text: str, k: int = 5) -> str:
+    """Collapse a VLM decode runaway -- a short token or line repeated many
+    times in a row -- to a single instance. LightOnOCR (greedy, no repetition
+    penalty) occasionally loops on fine print (e.g. one poster's cache is 63%
+    'KBA;' repeated ~4000x), and the raw markdown otherwise flows straight to
+    the structuring LLM and drowns the real content. Only a run of >k identical
+    short tokens/lines is collapsed, so normal prose (which never repeats the
+    same short token 6+ times consecutively) is untouched. O(n), no regex
+    backtracking, so it is safe on a 30k-char runaway."""
+    if not text:
+        return text
+    # 1) runs of identical (stripped) lines -> keep one
+    lines = text.split("\n")
+    out, i = [], 0
+    while i < len(lines):
+        j = i
+        while j < len(lines) and lines[j].strip() == lines[i].strip():
+            j += 1
+        if lines[i].strip() and (j - i) > k:
+            out.append(lines[i])
+        else:
+            out.extend(lines[i:j])
+        i = j
+    # 2) runs of an identical short token within a line -> keep one
+    collapsed = []
+    for ln in out:
+        toks, res, i = ln.split(" "), [], 0
+        while i < len(toks):
+            j = i
+            while j < len(toks) and toks[j] == toks[i]:
+                j += 1
+            if toks[i] and len(toks[i]) <= 20 and (j - i) > k:
+                res.append(toks[i])
+            else:
+                res.extend(toks[i:j])
+            i = j
+        collapsed.append(" ".join(res))
+    return "\n".join(collapsed)
+
+
 def scrub(text: str) -> str:
     if not text:
         return text
+    text = _collapse_loops(text)           # collapse VLM decode runaways first
     text = _FENCE_MARKER.sub("", text)     # drop ``` markers, keep caption prose
     text = _TABLE.sub(_table_repl, text)   # drop data tables, keep layout prose
     text = _IMAGE.sub("", text)            # drop image placeholders

poster2json/extract.py

@@ -1588,7 +1588,7 @@ def _generate(
 4. Each section must have its OWN "sectionTitle" and "sectionContent"
 5. Copy ALL poster text EXACTLY into sections - do not paraphrase, summarize, or skip any text. Every line of the poster text below must appear in your output.
 6. "Key Findings" ≠ "References": Key Findings = discoveries/results; References = numbered citations with authors/years
-7. Figure/table captions belong in imageCaptions/tableCaptions, NOT inside sectionContent.
+7. Figure/table captions belong in imageCaptions/tableCaptions, NOT inside sectionContent. A caption is the poster's own "Figure N: ..." / "Table N: ..." descriptive line. If a figure has BOTH a "Figure N:" caption line AND a generated image-description in Markdown image syntax "![description](...)", put the "Figure N:" CAPTION LINE in imageCaptions and DISCARD the "![...]" description text; never write the "![...]" alt-text into imageCaptions or a section. This only affects which text becomes a caption; it does not change how sections are split.
 8. Text without a clear header (e.g. contact info, URLs, footer text) is still a section — use "sectionTitle": "" with the verbatim text as "sectionContent". Do NOT skip any poster text.
 
 JSON SCHEMA (all top-level fields are REQUIRED):
@@ -3271,7 +3271,7 @@ def extract_json_with_retry(
         # penalty on the retry (not the primary) so healthy posters are
         # untouched.
         log(f"Retrying with max_tokens={MAX_RETRY_TOKENS}")
-        r_retry, _ = _generate(
+        r_retry, retry_eos = _generate(
             model, tokenizer, prompt, MAX_RETRY_TOKENS,
             repetition_penalty=RETRY_REPETITION_PENALTY,
         )
@@ -3281,13 +3281,17 @@ def extract_json_with_retry(
 
         # A short penalty retry can summarize away a real tail (References /
         # Acknowledgements / contact) that IS present in the source, closing
-        # cleanly yet dropping content. Unless the retry already covers every
-        # input header, also run the penalty-free shorter fallback and keep
-        # whichever candidate retains the most source headers -- a candidate
-        # that dropped a header cannot beat one that kept it.
+        # cleanly yet dropping content -- so also run the penalty-free shorter
+        # fallback and keep whichever candidate retains the most source headers
+        # (a candidate that dropped a header cannot beat one that kept it).
+        # But only spend that fallback generation when it could plausibly win:
+        # the retry itself ran away (unclean) OR it dropped 2+ source headers.
+        # A clean retry already covering all-but-one header is kept as-is -- the
+        # fallback could add at most one header and usually just burns a doomed
+        # generation (measured: +15-20 min on already-recovered runaways).
         n_heads = len(input_keys)
-        retry_full = n_heads and _header_coverage(res_retry, input_keys) >= n_heads
-        if not retry_full:
+        retry_cov = _header_coverage(res_retry, input_keys)
+        if n_heads and (not retry_eos or retry_cov < n_heads - 1):
             log("Using fallback shorter prompt (best-of candidate)")
             fallback_prompt = FALLBACK_PROMPT.format(raw_text=raw_text)
             r_fb, _ = _generate(model, tokenizer, fallback_prompt, MAX_RETRY_TOKENS)