File size: 6,051 Bytes
a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed 2f5b800 a15e3ed | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | """Spec checker: verify a plan's box table against a structured request spec, without eyes.
Spec schema (stored with ~40% of generated requests):
{
"entities": [{"class": "person", "count": 3}, {"class": "bench", "count": 1}],
"relations": [{"a": "person", "b": "bench", "rel": "left_of"}, ...], # rel in left_of/right_of/above/below
"text": ["OPEN 24/7", ...] # strings that must appear verbatim
}
Relations compare box centres (ids are numbered left-to-right, top-to-bottom, so the first instance of a
class is its leftmost/topmost one); counts accept separate rows per instance OR one collection row whose
desc states the count as digits or a number word.
"""
import json
import re
from bbox import split, valid_box
NUM_WORDS = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight",
9: "nine", 10: "ten", 11: "eleven", 12: "twelve", 15: "fifteen", 20: "twenty"}
RELS = {"left_of": lambda a, b: a[1] < b[1], "right_of": lambda a, b: a[1] > b[1],
"above": lambda a, b: a[0] < b[0], "below": lambda a, b: a[0] > b[0]}
def class_of(row_id: str) -> str:
m = re.match(r"(.+?)_(\d+)$", row_id)
return m.group(1) if m else row_id
def instance_index(row_id: str) -> int:
m = re.match(r"(.+?)_(\d+)$", row_id)
return int(m.group(2)) if m else 0
def centre(box: list) -> tuple:
return (box[0] + box[2]) / 2.0, (box[1] + box[3]) / 2.0 # (cy, cx)
def parse_plan(output: str):
"""(rows, reasons) for a single-line plan output; rows is None when it does not parse cleanly."""
reasons = []
caption, rows = split(output)
if rows is None:
return None, ["no JSON table found"]
for r in rows:
if not isinstance(r, dict) or valid_box(r.get("bbox")) is None:
reasons.append(f"invalid row {r!r}")
if reasons:
return None, reasons
if not is_plan_finished(caption, rows):
reasons.append("not every row id is cited as <id> in the caption")
return rows, reasons
def is_plan_finished(caption: str, rows: list) -> bool:
from bbox import ID
return all(isinstance(r.get("id"), str) and ID.fullmatch(r["id"]) and f"<{r['id']}>" in caption for r in rows)
def normalize_class(name: str) -> str:
"""lowercase + simple singularization, so spec vocabulary can meet plan id nouns."""
n = name.strip().lower()
if len(n) > 3 and n.endswith("s") and not n.endswith("ss"):
n = n[:-1]
return re.sub(r"\s+", " ", n)
def check_count(rows: list, cls: str, count: int, known_classes=None) -> str | None:
"""None when satisfied, else a reason string. With known_classes (the plan's id-noun
vocabulary), a class that matches nothing in the plan returns UNVERIFIABLE instead of a
failure — the checker cannot judge counts for entities the plan named differently."""
c = normalize_class(cls)
cls_rows = sorted((r for r in rows if normalize_class(class_of(r["id"])) == c),
key=lambda r: instance_index(r["id"]))
if len(cls_rows) == count:
return None
# collection row: one row of this class whose desc states the count as digits or a number word
for r in cls_rows:
d = r["desc"].lower()
if re.search(rf"\b{count}\b", d) or (count in NUM_WORDS and re.search(rf"\b{NUM_WORDS[count]}\b", d)):
return None
if known_classes is not None and c not in {normalize_class(k) for k in known_classes}:
return f"UNVERIFIABLE count: {cls!r} not in plan vocabulary"
return f"{cls}: {len(cls_rows)} row(s) vs stated count {count}, no collection row stating it"
def check_relation(rows: list, a: str, rel: str, b: str, known_classes=None) -> str | None:
unres = known_classes is not None
if rel not in RELS:
return (f"UNVERIFIABLE relation: unsupported {rel!r}" if unres else f"unknown relation {rel!r}")
cmp = RELS[rel]
# resolve "person" (first instance) or "person_2" (that instance)
def pick(name):
if re.match(r"(.+?)_(\d+)$", name):
hits = [r for r in rows if r["id"] == name]
else:
hits = sorted((r for r in rows if class_of(r["id"]) == name),
key=lambda r: instance_index(r["id"]))
if not hits:
return None
(cy, cx) = centre(hits[0]["bbox"])
return (cx, cy)
pa, pb = pick(a), pick(b)
if pa is None:
return (f"UNVERIFIABLE relation: {a!r} not in plan vocabulary" if unres
else f"relation {a!r} {rel} {b!r}: no row for {a!r}")
if pb is None:
return (f"UNVERIFIABLE relation: {b!r} not in plan vocabulary" if unres
else f"relation {a!r} {rel} {b!r}: no row for {b!r}")
# pick() returns (cx, cy); RELS compare cx for left/right, cy for above/below via tuples
ax, ay = pa
bx, by = pb
ok = {"left_of": ax < bx, "right_of": ax > bx, "above": ay < by, "below": ay > by}[rel]
return None if ok else f"relation violated: {a!r} ({ax:.0f},{ay:.0f}) {rel} {b!r} ({bx:.0f},{by:.0f})"
def check_text(rows: list, strings: list) -> list:
out = []
for s in strings:
if not any(s in r["desc"] for r in rows):
out.append(f"quoted string {s!r} not verbatim in any desc")
return out
def check_plan(output: str, spec: dict, known_classes=None) -> tuple[bool, list]:
"""(ok, reasons) for one teacher/student output against its spec.
Reasons beginning with 'UNVERIFIABLE' are checker limitations, not plan errors."""
rows, reasons = parse_plan(output)
if rows is None:
return False, reasons
for e in spec.get("entities", []):
r = check_count(rows, e["class"], e["count"], known_classes)
if r:
reasons.append(r)
for rel in spec.get("relations", []):
r = check_relation(rows, rel["a"], rel["rel"], rel["b"], known_classes)
if r:
reasons.append(r)
reasons.extend(check_text(rows, spec.get("text", [])))
return not reasons, reasons
|