| """Structural defect gate + question parser, extracted verbatim from annotate_v2.py so other |
| drivers can reuse them without duplicating the logic. Measured on the first 362 generated questions: |
| 12% had near-duplicate options and 5% a gold option unsupported by the source material.""" |
| import collections, json, re |
|
|
| _WORD = re.compile(r"[a-z0-9']{4,}") |
| _STOP = set("""that this with from into over under after before then than which what were was |
| been being have has had will would could should there here they them their your mine ours |
| first second third fourth i my me the and or of to in on at for a an it its is are be""".split()) |
|
|
|
|
| def _content(s): |
| return {w for w in _WORD.findall(re.sub(r"^\s*[A-D][\.\)]\s*", "", s or "").lower()) |
| if w not in _STOP} |
|
|
|
|
| def structural_issues(q, desc): |
| """Shape defects a blind-attack filter does not reliably catch. |
| |
| Measured on the first 362 questions: 12% had two near-duplicate options and 5% had a gold |
| option whose content never appeared in the description. Compound questions are the main |
| offender -- built as a factorial grid over only TWO values per slot, they collapse into a |
| 2-way guess ("'Luyben Av' + minivan" vs "'Luyben Av' + van").""" |
| issues = [] |
| opts = q.get("options") or [] |
| gold = str(q.get("answer", "")).upper()[:1] |
| if len(opts) != 4 or gold not in "ABCD": |
| return ["malformed"] |
| bodies = [re.sub(r"^\s*[A-D][\.\)]\s*", "", o).strip() for o in opts] |
| sets = [_content(b) for b in bodies] |
|
|
| for i in range(4): |
| for j in range(i + 1, 4): |
| if sets[i] and sets[j]: |
| jac = len(sets[i] & sets[j]) / len(sets[i] | sets[j]) |
| if jac > 0.8: |
| issues.append("dup_options") |
| break |
| if issues: |
| break |
|
|
| |
| if len(bodies) == 4: |
| counts = collections.Counter() |
| for b in bodies: |
| for part in re.split(r"\s+and\s+|,\s+", b): |
| p = " ".join(sorted(_content(part))) |
| if p: |
| counts[p] += 1 |
| if counts and max(counts.values()) >= 3: |
| issues.append("repeated_component") |
|
|
| gi = "ABCD".index(gold) |
| others = [len(b) for k, b in enumerate(bodies) if k != gi] |
| if abs(len(bodies[gi]) - (sum(others) / 3)) > 30: |
| issues.append("gold_len_outlier") |
|
|
| dw = _content(desc) |
| gw = sets[gi] |
| if gw and len(gw - dw) / len(gw) > 0.7: |
| issues.append("gold_unsupported_by_desc") |
| return issues |
|
|
|
|
|
|
| def parse_questions(txt): |
| """Reasoning models often wrap the JSON in prose or a ```json fence despite response_format, |
| and sometimes run out of budget mid-object. Recover what we can instead of dropping the round.""" |
| if not txt: |
| return [] |
| qs = None |
| for cand in (txt, |
| (re.search(r"```(?:json)?\s*(.*?)```", txt, re.S) or [None, None])[1], |
| (re.search(r"\{.*\}", txt, re.S) or [None])[0]): |
| if not cand: |
| continue |
| try: |
| obj = json.loads(cand) |
| if isinstance(obj, dict): |
| qs = obj.get("questions") |
| elif isinstance(obj, list): |
| qs = obj |
| if qs: |
| break |
| except Exception: |
| continue |
| if not qs: |
| |
| qs = [] |
| for m in re.finditer(r'\{[^{}]*"question"\s*:.*?\}(?=\s*[,\]])', txt, re.S): |
| try: |
| qs.append(json.loads(m.group(0))) |
| except Exception: |
| pass |
| if not qs: |
| return [] |
| out = [] |
| for q in qs: |
| if not isinstance(q, dict) or not q.get("question"): |
| continue |
| opts = q.get("options") or [] |
| if len(opts) != 4 or str(q.get("answer", "")).upper()[:1] not in "ABCD": |
| continue |
| out.append(q) |
| return out |
|
|
|
|
| BATCH_SYS = ("Answer each numbered multiple-choice question independently. " |
| 'Reply with ONLY JSON mapping question number to letter, e.g. {"1":"A","2":"C"}. ' |
| "Answer every question; if unsure, still give your best single letter.") |
|
|
|
|
