From 6d79dfbd83b492053d1099d30c3418405aa19b99 Mon Sep 17 00:00:00 2001 From: heaven Date: Fri, 7 Aug 2026 16:52:21 +0300 Subject: [PATCH] Freeze the absolute judging rig before the second pass: family pinned into the key, salt out of the repo, per-axis justification, floor verdict, position control, judge identity, ledger covering the arm tags it pays --- eval/role_topology/absjudge.py | 566 +++++++++++++++++++++++++++++++ eval/role_topology/agentjudge.py | 45 +++ eval/role_topology/bakeoff.py | 7 +- eval/role_topology/buy.py | 39 +++ 4 files changed, 656 insertions(+), 1 deletion(-) create mode 100644 eval/role_topology/absjudge.py diff --git a/eval/role_topology/absjudge.py b/eval/role_topology/absjudge.py new file mode 100644 index 00000000..c29fd6a1 --- /dev/null +++ b/eval/role_topology/absjudge.py @@ -0,0 +1,566 @@ +#!/usr/bin/env python3 +"""АБСОЛЮТНЫЙ СУДЕЙСКИЙ РИГ. $0 по ключам провайдеров. + +⚠ Заведён 07.08 по находке ЧЕТЫРЁХ независимых судей-агентов. Каждому была выдана своя пачка +ПАРНЫХ пакетов «исходник + вариант 1 + вариант 2»; ни один не знал о трёх других. Все четыре +самостоятельно свернули пары обратно: дедуплицировали уникальные тексты, оценили КАЖДЫЙ ОДИН РАЗ +против исходника и разнесли числа по пакетам. Четыре из четырёх — это не сбой исполнителя, это +поведение инструмента, и оснастка обязана следовать за ним, а не бороться с ним. + +ЧТО ДАЁТ ПЕРЕХОД НА АБСОЛЮТНУЮ ШКАЛУ. + +1. **Позиция исчезает по построению.** Текст оценивается вне пары, значит «первый/второй» не + существует как понятие. Зеркальная раскладка, которую я чинил трижды и трижды получал + вырождение, здесь не нужна — нечего зеркалить. +2. **Работа падает втрое.** 160 парных пакетов = 320 прочтений; уникальных текстов 128. Причём + парная схема покупала 4 контраста, а абсолютная даёт ВСЕ 7 объявленных, включая деконфаунды. +3. **Строгость калибрована внутри единицы.** Все варианты ОДНОГО исходника судятся в одном + заходе, а контраст считается ВНУТРИ единицы и лишь затем усредняется по единицам. Дрейф + строгости между единицами в контраст не попадает — он сокращается вычитанием. + +ЧЕГО ЭТО НЕ ЧИНИТ. Шум ОДНОГО вызова велик: два прогона одного и того же арма на одном входе +расходятся на sd≈2.7 ошибки по единице (контроль пола, n=16). Значит на ОТДЕЛЬНОЙ главе армы +надёжно не упорядочены — пере-прогон сдвинет счёт сильнее, чем разница между армами. Упорядочено +только среднее: парный дизайн делит шум на √n, и при 16 единицах различимый эффект ≈1.9. +⚠ Первая версия этой шапки утверждала, что эффект ниже двух не различим «никаким числом единиц». +Это неверно и снято собственным замером: порог кладёт стандартная ошибка среднего, а она падает +с ростом n. Формулировка была завышением порога и держалась ровно до того, как пол измерили. + +СЛЕПОТА. Метки Т1..Тn внутри единицы, порядок перемешан хешем соли и uid: из метки не выводится +ни арм, ни то, редактированный это текст или черновик. Ключ лежит отдельно и судье не даётся. + +ПЕРСИСТ. Судья пишет ответ файлом САМ, в `aj-abs/<токен>.txt`. Так убирается моя транскрипция — +тот самый канал, по которому в третьей редакции потерялись обоснования, а слепое чтение не +попало на диск вовсе. `ingest` только разбирает и проверяет; голос с ненулевой осью и пустым +обоснованием отвергается (условие 2 амендмента владельца 07.08). + +Запуск: --selfcheck проверка разбора и арифметики на входах с известным ответом, $0 + --emit выпустить задания судьям, $0 + --ingest разобрать ответы в голоса, $0 + --controls что показали контроли (читать ДО боевых чисел), $0 + --score контрасты с поправкой Холма, $0 +""" +from __future__ import annotations +import hashlib +import json +import re +import statistics as st +import sys +from pathlib import Path + +REPO = Path("/home/ubuntu/projects/textmachine") +sys.path.insert(0, str(REPO / "eval" / "role_topology")) + +import bakeoff as BO # noqa: E402 +import judges as J # noqa: E402 + +OUT = Path.home() / "books" / "role-topology" +KEYS = OUT / "blind-keys" + + +def _dirs(): + """Каталоги прохода. ВТОРОЙ проход обязан лежать отдельно: он и есть репликация, + и затирание первого превратило бы её в пере-запись.""" + return (OUT / f"aj-{PASS}-tasks", OUT / f"aj-{PASS}", OUT / f"aj-{PASS}-votes") +# ⚠ СОЛЬ ЖИВЁТ ВНЕ РЕПОЗИТОРИЯ. Адверсариальное ревью 07.08 восстановило 138 меток из 138, не +# открывая ключ: `layout()` — чистая функция от соли и `uid = sha1(source)`, а источник лежит В +# ЗАДАНИИ. Пока соль была константой в коде, слепота держалась только запретом судье читать код. +# Теперь она в файле рядом с ключом, куда судье ходить запрещено тем же правилом, что и к ключу. +def _salt(name: str = "abs") -> str: + f = Path.home() / "books" / "role-topology" / "blind-keys" / f"SALT-{name}.txt" + if not f.exists(): + import secrets # noqa: PLC0415 + f.parent.mkdir(parents=True, exist_ok=True) + f.write_text(secrets.token_hex(16), encoding="utf-8") + return f.read_text(encoding="utf-8").strip() + + +PASS = "abs" # переключается --emit2 на вторую пачку +SALT = _salt(PASS) + +# Армы, попадающие в пачку. F3 — собственный черновик пака (текст и цена из одного вызова). +# D/D_ берутся из второй редакции СОЗНАТЕЛЬНО: однопроходки черновика не видят, их вход +# (исходник + блок закона) в обеих редакциях побайтно один, и это проверяется в selfcheck. +ARMS = ("F3", "A", "A_law", "B", "D", "D_") + +# СЕМЕЙСТВО КОНТРАСТОВ, объявленное ДО первого ответа судьи. Поправка Холма считается по всем +# семи; сузить семейство после того, как увидены p-значения, — это и есть p-hacking, и именно +# за него снята первая редакция. Знак: перевес > 0 означает «ПЕРВЫЙ арм лучше». +FAMILY = [ + ("A", "F3", "редактор поверх черновика против самого черновика"), + ("B", "F3", "другой движок-редактор поверх ТОГО ЖЕ черновика"), + ("D_", "A", "однопроходка против связки черновик+редактор"), + ("D", "A", "однопроходка с переливкой абзацев против связки"), + ("A_law", "A", "деконфаунд: сколько покупает банкнота-как-закон"), + ("A_law", "B", "два движка, оба с законом"), + ("D", "D_", "деконфаунд: сколько покупает переливка абзацев"), +] + +FORMAT_HEAD = """Оцени КАЖДЫЙ вариант ОТДЕЛЬНО против исходника — не сравнивая варианты между +собой. Порядок вариантов ничего не значит и специально перемешан. + +Ответ ЗАПИШИ ФАЙЛОМ в {path} — ровно в таком виде и ничем больше, блок на каждую метку: + +{skeleton} +ПОЧЕМУ обязательно для КАЖДОЙ ненулевой оси: короткая ЦИТАТА из текста через « | ». +Число без цитаты не принимается и на диск не попадает: именно из-за отсутствия цитат показания +прошлых судей оказались непроверяемыми. Ноль по оси обоснования не требует. +""" + + +def utoken(uid: str) -> str: + return hashlib.sha1(f"{_salt(PASS)}|unit|{uid}".encode()).hexdigest()[:10] # noqa: S324 + + +def layout(uid: str, slots: list[str]) -> list[str]: + """Порядок меток внутри единицы: детерминированная перестановка по хешу, не по алфавиту.""" + return sorted(slots, key=lambda s: hashlib.sha1(f"{_salt(PASS)}|{uid}|{s}".encode()).hexdigest()) # noqa: S324 + + +def build_unit(u: dict) -> tuple[str, dict]: + """Задание на одну единицу + ключ раскладки. Контроли подмешаны и неотличимы от боевых.""" + slots: dict[str, str] = {a: BO.text3_of(a, u) for a in ARMS} + kinds: dict[str, str] = {a: "боевой" for a in ARMS} + + clean = slots["A"] + planted, n = _plant(clean) + if n >= 2: + slots["CTRLdecoy"], kinds["CTRLdecoy"] = planted, "контроль-декой" + # ⚠ ПОЛ КЛАДЁТСЯ ПАРОЙ, а не против боевого арма `A`. Поймано чтением кода 07.08: `bo3-Aprime` + # куплен по `build_msgs` (черновик ИЗ КОРПУСА), а боевой `A` третьей редакции — по `build_msgs3` + # (СОБСТВЕННЫЙ черновик). Их входы различаются, и пол мерил бы разницу черновиков, а не шум + # вызова. Повтором `Aprime` является `bo2-A`, и именно он идёт второй половиной пары. + fa, fb = OUT / f"bo2-A-{u['uid']}.json", OUT / f"bo3-Aprime-{u['uid']}.json" + if fa.exists() and fb.exists(): + slots["CTRLfloorA"] = json.loads(fa.read_text(encoding="utf-8"))["content"] + slots["CTRLfloorB"] = json.loads(fb.read_text(encoding="utf-8"))["content"] + kinds["CTRLfloorA"] = kinds["CTRLfloorB"] = "контроль-пол" + + order = layout(u["uid"], list(slots)) + label = {name: f"Т{i + 1}" for i, name in enumerate(order)} + skel = "\n".join(f"{label[n]}-ВЕРНОСТЬ: <число>\n{label[n]}-ТЕРМИН: <число>\n" + f"{label[n]}-ЯЗЫК: <число>\n{label[n]}-ФОРМА: <число>\n" + f"{label[n]}-ПОЧЕМУ: <цитаты>\n" for n in order) + tok = utoken(u["uid"]) + # Шапка своя, а не `J.RUBRIC`: та написана под ПАРУ («два русских перевода», «два варианта») + # и в абсолютной раскладке, где меток до восьми, противоречила бы заданию. Определения осей + # берутся из неё дословно — меняется только обрамление. + axes_def = J.RUBRIC.split("Посчитай ОШИБКИ", 1)[1].split("Отвечай РОВНО")[0].rstrip() + ANSW = _dirs()[1] + body = [f"Ты — литературный редактор-эксперт. Тебе дан ИСХОДНИК на китайском и {len(order)} " + f"независимых русских перевода этого же фрагмента под слепыми метками.", + "", "Посчитай ОШИБКИ" + axes_def, + "", FORMAT_HEAD.format(path=ANSW / f"{tok}.txt", skeleton=skel), + "", "=" * 60, "ИСХОДНИК:", u["source"]] + for n in order: + body += ["", "=" * 60, f"{label[n]}:", slots[n]] + key = {label[n]: dict(arm=n, kind=kinds[n], uid=u["uid"], + sig=hashlib.sha1(slots[n].encode()).hexdigest()[:12]) # noqa: S324 + for n in order} + return "\n".join(body), key + + +_PLANTS = [ + (r"\bне\s+(выдерж\w+)", r"легко \1", "инверсия полярности"), + (r"\bдесят(ь|и)\b", "сорок", "подмена величины"), + (r"\bсто\b", "триста", "подмена величины"), + (r"\bпоразительн(\w+)", r"взгрумительн\1", "выдуманное слово"), + (r"\bспокойн(\w+)", r"безмятежн\1 и невозмутительн\1", "выдуманное слово"), + (r"—\s*", '"', "сбой диалоговой вёрстки"), +] + + +def _plant(text: str) -> tuple[str, int]: + """Контролируемая деградация. Число РЕАЛЬНО применённых замен возвращается: клетка, где + посадить не удалось, в декой не берётся, иначе «не пойман» будет означать «не было».""" + out, n = text, 0 + for pat, rep, _c in _PLANTS: + new, cnt = re.subn(pat, rep, out, count=1) + if cnt: + out, n = new, n + cnt + return out, n + + +def emit() -> None: + TASKS, ANSW, VOTES = _dirs() + TASKS.mkdir(parents=True, exist_ok=True) + KEYS.mkdir(parents=True, exist_ok=True) + ANSW.mkdir(parents=True, exist_ok=True) + keys, n_tx = {}, 0 + for u in BO.units(): + body, key = build_unit(u) + tok = utoken(u["uid"]) + (TASKS / f"{tok}.txt").write_text(body, encoding="utf-8") + keys[tok] = key + n_tx += len(key) + # ⚠ СЕМЕЙСТВО ВПЕЧАТЫВАЕТСЯ В КЛЮЧ, который создаётся ДО существования хоть одного ответа. + # Так порядок «объявлено → отвечено» доказывается артефактом, а не словом исполнителя. + # Заведено после того, как ревью показало: `absjudge.py` незакоммичен и датируется ПОЗЖЕ + # последнего ответа судьи, то есть провенанс проверить было нечем. + (KEYS / f"{PASS}-KEY.json").write_text(json.dumps( + dict(_семейство=[f"{a} vs {b} — {w}" for a, b, w in FAMILY], + _армы=list(ARMS), _проход=PASS, **keys), ensure_ascii=False, indent=1), + encoding="utf-8") + print(f"заданий {len(keys)} → {TASKS} · прочтений {n_tx} (парная схема требовала 320)") + print(f"ключ → {KEYS}/abs-KEY.json · судье НЕ давать") + + +def ingest() -> None: + _TASKS, ANSW, VOTES = _dirs() + if not ANSW.exists(): + print(f"нет каталога ответов {ANSW}") + return + keys = {k: v for k, v in json.loads((KEYS / f"{PASS}-KEY.json").read_text( + encoding="utf-8")).items() if not k.startswith("_")} + # ⚠ ИДЕНТИЧНОСТЬ СУДЬИ. Первая версия рига её не персистировала вовсе, и по диску нельзя было + # ни посчитать согласие судей, ни разложить вердикты по семействам (требование промта стр.79). + # Поймано адверсариальным ревью 07.08. Карта раздачи лежит рядом с ключом и судье не даётся. + jf = KEYS / "abs-JUDGES.json" + judges = json.loads(jf.read_text(encoding="utf-8")) if jf.exists() else {} + VOTES.mkdir(parents=True, exist_ok=True) + ok = bad = 0 + reasons: dict[str, int] = {} + + def fail(r: str) -> None: + nonlocal bad + bad += 1 + reasons[r] = reasons.get(r, 0) + 1 + + for f in sorted(ANSW.glob("*.txt")): + key = keys.get(f.stem) + if not key: + fail("токена нет в ключе") + continue + txt = f.read_text(encoding="utf-8") + rows = {} + for lab, meta in key.items(): + ax = {} + for a in J.AXES: + # ⚠ `[ \t]*`, а НЕ `\s*`: `\s` включает перевод строки, и пустое поле молча + # утаскивало значение СЛЕДУЮЩЕЙ строки. Поймано известным входом в selfcheck — + # голос без обоснования проходил с обоснованием, списанным с соседней строки. + m = re.search(rf"^{lab}-{a}[ \t]*:[ \t]*(\d+)[ \t]*$", txt, re.M) + if m: + ax[a] = int(m.group(1)) + # обоснование может занимать несколько строк — берём до следующей метки или конца + wm = re.search(rf"^{lab}-ПОЧЕМУ[ \t]*:[ \t]*(.*?)(?=^\S+-(?:{'|'.join(J.AXES)}|ПОЧЕМУ)" + rf"[ \t]*:|\Z)", txt, re.M | re.S) + why = wm.group(1).strip() if wm else "" + if len(ax) != len(J.AXES): + fail(f"не разобран блок {lab}") + break + # ⚠ ПОИМЁННО ПО ОСЯМ, а не «непустая строка на блок». Ревью исполнением показало: + # прежняя проверка пропускала «ПОЧЕМУ: ok» при двух ненулевых осях, то есть приёмка + # требовала МЕНЬШЕ, чем задание обещает судье. Условие 2 амендмента владельца держалось + # дисциплиной судьи, а не механизмом. Теперь каждая ненулевая ось обязана быть названа. + miss = [a for a in J.AXES if ax[a] and a not in (why or "").upper()] + if miss: + fail(f"ось без обоснования: {'/'.join(miss)}") + break + rows[lab] = dict(**meta, **ax, why=why, errors=sum(ax.values()), + slot=int(lab[1:]), judge=judges.get(f.stem, "?")) + else: + (VOTES / f"{f.stem}.json").write_text( + json.dumps(rows, ensure_ascii=False), encoding="utf-8") + ok += 1 + print(f"принято единиц {ok} · отвергнуто {bad} {reasons if reasons else ''}") + + +def _by_unit() -> dict[str, dict[str, dict]]: + VOTES = _dirs()[2] + out = {} + for f in VOTES.glob("*.json"): + rows = json.loads(f.read_text(encoding="utf-8")) + uid = next(iter(rows.values()))["uid"] + out[uid] = {r["arm"]: r for r in rows.values()} + return out + + +def _margins(a: str, b: str) -> list[float]: + """Перевес ЗА арм `a` внутри каждой единицы: ошибки(b) − ошибки(a).""" + return [d[b]["errors"] - d[a]["errors"] + for d in _by_unit().values() if a in d and b in d] + + +def score() -> None: + data = _by_unit() + if not data: + print("голосов нет — сначала --ingest") + return + rows = [] + for a, b, what in FAMILY: + m = _margins(a, b) + if len(m) < 3: + continue + rows.append((a, b, what, m, BO.sign_perm_p(m))) + order = sorted(range(len(rows)), key=lambda i: rows[i][4]) + holm, k = {}, len(rows) + run = 0.0 + for rank, i in enumerate(order): + run = max(run, min(1.0, rows[i][4] * (k - rank))) + holm[i] = run + print(f"единиц с голосами: {len(data)} · семейство объявлено до ответов, " + f"поправка Холма по {k} контрастам\n") + print(f"{'контраст':14s}{'ед.':>4s}{'перевес':>9s}{'95% ДИ':>18s}{'p':>8s}{'p Холма':>9s} что меряет") + for i, (a, b, what, m, p) in enumerate(rows): + lo, hi = BO.boot_ci(m) + mark = "✔" if holm[i] < 0.05 else " " + print(f"{a + ' vs ' + b:14s}{len(m):4d}{st.mean(m):+9.2f} [{lo:+.2f}, {hi:+.2f}]" + f"{p:8.4f}{holm[i]:9.4f}{mark} {what}") + print("\n⚠ ПОРОГ КЛАДЁТ ПОЛ, А НЕ SD. Шум одного вызова sd≈2.7 на единицу — это значит, что на" + "\n ОТДЕЛЬНОЙ главе армы надёжно не упорядочены: пере-прогон того же арма сдвинет счёт" + "\n сильнее, чем разница между армами. Упорядочено только СРЕДНЕЕ по единицам.") + + +def axes() -> None: + """Разложение контрастов по осям. Заведено потому, что в третьей редакции ОДНА ось (ФОРМА) + переворачивала знак вывода: она штрафует слипание абзацев, а слипание есть прямое исполнение + мандата дискурс-перевёрстки боевого `editor.md`. Сумма это прячет, разложение — показывает.""" + data = _by_unit() + if not data: + print("голосов нет — сначала --ingest") + return + print(f"{'контраст':14s}" + "".join(f"{a:>12s}" for a in J.AXES) + f"{'сумма':>10s}") + for a, b, _w in FAMILY: + row = [] + for ax in J.AXES: + m = [d[b][ax] - d[a][ax] for d in data.values() if a in d and b in d] + # ⚠ Критерий значимости — ТОЧНЫЙ знаковый тест, а не «бутстрап-ДИ не накрывает ноль». + # Первая версия метила звёздочку по ДИ; адверсариальное ревью исполнением показало, + # что так помечались значимыми три клетки с p>0.05 (перцентильный бутстрап при n=16 + # накрывает ~93%, а не 95%). ДИ отвечает «где лежит среднее», а не «отличимо ли от нуля». + row.append(f"{st.mean(m):+7.2f}{'*' if BO.sign_perm_p(m) < 0.05 else ' '} ") + tot = _margins(a, b) + print(f"{a + ' vs ' + b:14s}" + "".join(row) + f"{st.mean(tot):+10.2f}") + print("\n* = p<0.05 точного знакового теста, БЕЗ поправки на 28 клеток. Разложение —" + "\n разведочное: `score` корректирует на 7 гипотез, здесь их 28. Читать как направление," + "\n не как подтверждение. Перевес > 0 ⇒ ПЕРВЫЙ арм лучше по этой оси.") + + +def position() -> None: + """Остаточная позиционная фора: влияет ли НОМЕР МЕТКИ внутри задания на счёт. + + ⚠ Заведено 07.08 адверсариальным ревью. Шапка рига утверждала, что «позиция исчезает по + построению», и контроля не ставила вовсе — регрессия против третьей редакции, где + `bakeoff.position_bias()` был. Утверждение неверно: меток в задании 8–9, порядок один, + и хеш-перестановка НЕ сбалансирована по армам. Здесь наклон измеряется, а контрасты + печатаются с поправкой на него — чтобы видеть, какие выводы от раскладки зависят. + """ + data = _by_unit() + if not data: + print("голосов нет — сначала --ingest") + return + xs, ys = [], [] + for d in data.values(): + mx = st.mean([r["slot"] for r in d.values()]) + my = st.mean([r["errors"] for r in d.values()]) + for r in d.values(): + xs.append(r["slot"] - mx) + ys.append(r["errors"] - my) + slope = sum(a * b for a, b in zip(xs, ys)) / sum(a * a for a in xs) + print(f"наклон {slope:+.3f} ошибки на шаг метки (внутри единицы, n={len(xs)})") + print(f"средняя позиция арма: " + " · ".join( + f"{a} {st.mean([d[a]['slot'] for d in data.values() if a in d]):.2f}" + for a in ARMS)) + print(f"\n{'контраст':14s}{'перевес':>9s}{'Δметки':>8s}{'вклад':>8s}{'с поправкой':>13s}{'p':>9s}") + for a, b, _w in FAMILY: + m = [d[b]["errors"] - d[a]["errors"] for d in data.values() if a in d and b in d] + dl = [d[a]["slot"] - d[b]["slot"] for d in data.values() if a in d and b in d] + corr = [mi + slope * x for mi, x in zip(m, dl)] + print(f"{a + ' vs ' + b:14s}{st.mean(m):+9.2f}{st.mean(dl):+8.2f}" + f"{-slope * st.mean(dl):+8.2f}{st.mean(corr):+13.2f}{BO.sign_perm_p(corr):9.4f}") + print("\nВывод, зависящий от раскладки, — тот, чей знак или значимость меняются поправкой.") + + +def judges_agree() -> None: + """Согласие судей и разброс порогов. Возможно только после персиста идентичности судьи.""" + data = _by_unit() + per: dict[str, list[float]] = {} + for d in data.values(): + j = next(iter(d.values()))["judge"] + per.setdefault(j, []).append(st.mean([r["errors"] for r in d.values()])) + if len(per) < 2: + print("идентичность судьи не персистирована — согласие не считается") + return + lv = {j: st.mean(v) for j, v in per.items()} + print(f"судей {len(per)} · средний уровень строгости по судьям: " + f"{min(lv.values()):.2f}…{max(lv.values()):.2f} (разброс {max(lv.values()) - min(lv.values()):.2f})") + print(" " + " · ".join(f"{j} {v:.2f}" for j, v in sorted(lv.items()))) + print("\n⚠ Разброс порогов между судьями — причина, по которой контраст считается ВНУТРИ") + print(" единицы: единицу целиком судит ОДИН судья, и его порог сокращается вычитанием.") + + +def controls() -> None: + data = _by_unit() + if not data: + print("голосов нет — сначала --ingest") + return + print("КОНТРОЛИ САМОГО СУДЬИ — читать ДО боевых чисел\n") + dec = [d["A"]["errors"] - d["CTRLdecoy"]["errors"] + for d in data.values() if "CTRLdecoy" in d and "A" in d] + if dec: + print(f" ДЕКОЙ посаженная деградация против чистого: {st.mean(dec):+.2f} " + f"· поймано {sum(1 for x in dec if x < 0)}/{len(dec)} (нужен отрицательный знак)") + flo = [d["CTRLfloorA"]["errors"] - d["CTRLfloorB"]["errors"] + for d in data.values() if "CTRLfloorA" in d and "CTRLfloorB" in d] + if flo: + lo, hi = BO.boot_ci(flo) + print(f" ПОЛ два вызова ОДНОГО арма на одном входе: {st.mean(flo):+.2f} " + f"[{lo:+.2f}, {hi:+.2f}] n={len(flo)} · истинная разница НОЛЬ") + # ⚠ sd по единицам — это НЕ порог различимости. Порог кладёт стандартная ошибка + # СРЕДНЕГО, то есть sd/√n, и парный дизайн именно этим и полезен. Первая печать этого + # блока написала «перевес меньше sd неотличим» — завышение порога вдвое-втрое, + # снятое до того, как попало в отчёт. + sd = st.pstdev(flo) + se = sd / len(flo) ** 0.5 + print(f" шум одного вызова: sd по единицам {sd:.2f} · ст.ошибка среднего " + f"{se:.2f} при n={len(flo)}") + # ⚠ ВЕРДИКТ, а не только числа. Ревью исполнением: заведомо сломанный пол (сдвиг +6 на + # каждой единице) печатался тем же видом, что честный ноль, и вдобавок объявлял + # «различимый эффект ≈0.00», потому что sd при систематическом сдвиге равен нулю. + lo0, hi0 = BO.boot_ci(flo) + ok = lo0 <= 0 <= hi0 + print(f" ⇒ различимый средний эффект ≈ {2.8 * se:.2f} (80% мощности); " + "sd сам по себе порогом НЕ является — парный дизайн делит его на √n") + print(f" ВЕРДИКТ: {'пол ЧЕСТЕН — ноль внутри интервала' if ok else '⛔ ПОЛ СМЕЩЁН: ноль ВНЕ интервала, боевые числа снимаются'}") + if sd < 1e-9: + print(" ⛔ нулевой sd при ненулевом среднем = систематический сдвиг, не шум") + twin = [(u[:8], x["arm"], y["arm"], x["errors"] - y["errors"]) + for uid, d in data.items() for u in [uid] + for x in d.values() for y in d.values() + if x["arm"] < y["arm"] and x["sig"] == y["sig"]] + if twin: + bad = [t for t in twin if t[3] != 0] + print(f" БЛИЗНЕЦ побайтно одинаковых пар: {len(twin)} · " + f"перевес ровно ноль в {len(twin) - len(bad)}/{len(twin)}") + for t in bad: + print(f" ⚠ {t[0]} {t[1]}/{t[2]} разошлись на {t[3]}") + else: + print(" БЛИЗНЕЦ побайтно одинаковых текстов в пачке нет") + + +# -------------------------------------------------------------------------------------------- +def selfcheck() -> int: + """Проверка ИСПОЛНЕНИЕМ: разбор, арифметика перевеса и Холм на входах с известным ответом.""" + bad = 0 + + def chk(name: str, got, want) -> None: + nonlocal bad + ok = got == want + bad += not ok + print(f"[{'OK ' if ok else 'ПРОВАЛ'}] {name}" + ("" if ok else f" получено {got!r}, ждали {want!r}")) + + # 1. Однопроходки: вход второй и третьей редакции обязан совпадать побайтно, иначе брать + # их тексты из bo2 нельзя. + u = BO.units()[0] + for arm in ("D", "D_"): + chk(f"вход {arm} одинаков в обеих редакциях", + BO.build_msgs(arm, u) == BO.build_msgs3(arm, u), True) + # Пол обязан быть ПАРОЙ ПОВТОРОВ. Проверяется тем, что вход боевого `A` третьей редакции + # ОТЛИЧАЕТСЯ от входа пары пола: если бы совпадал, пол можно было бы брать против боевого. + chk("вход боевого A ≠ вход пары пола (иначе пол мерил бы черновик)", + BO.build_msgs3("A", u) != BO.build_msgs("A", u), True) + for u2 in BO.units(): + k = build_unit(u2)[1] + arms_in = {v["arm"] for v in k.values()} + if "CTRLfloorA" in arms_in: + chk("пол лежит парой, а не одиночкой", "CTRLfloorB" in arms_in, True) + break + + # 2. Раскладка: перестановка детерминирована и не алфавитна. + sl = ["F3", "A", "A_law", "B", "D", "D_"] + chk("раскладка детерминирована", layout("u1", sl), layout("u1", sl)) + chk("раскладка зависит от единицы", layout("u1", sl) != layout("u2", sl), True) + + # 3. Разбор: ненулевая ось без обоснования отвергается, нулевая — принимается. + import tempfile # noqa: PLC0415 + global _dirs, KEYS # noqa: PLW0603 + sv = (_dirs, KEYS) + d = Path(tempfile.mkdtemp()) + VOTES, ANSW, KEYS = d / "v", d / "a", d / "k" + for q in (VOTES, ANSW, KEYS): + q.mkdir(parents=True) + _dirs = lambda: (d / "t", ANSW, VOTES) # noqa: E731 + key = {"tok": {"Т1": dict(arm="A", kind="боевой", uid="u1", sig="aa"), + "Т2": dict(arm="B", kind="боевой", uid="u1", sig="bb")}} + (KEYS / f"{PASS}-KEY.json").write_text(json.dumps(key), encoding="utf-8") + + def answer(t1: tuple, w1: str, t2: tuple, w2: str) -> None: + (ANSW / "tok.txt").write_text( + "".join(f"Т{i}-{a}: {v}\n" for i, t in ((1, t1), (2, t2)) + for a, v in zip(J.AXES, t)) .replace("Т1-ФОРМА", "Т1-ФОРМА") + + f"Т1-ПОЧЕМУ: {w1}\nТ2-ПОЧЕМУ: {w2}\n", encoding="utf-8") + + answer((1, 0, 0, 0), "", (0, 0, 0, 0), "") + ingest() + chk("ненулевая ось без цитаты отвергнута", list(VOTES.glob("*.json")), []) + answer((1, 0, 0, 0), "ВЕРНОСТЬ: «кривая фраза»", (0, 0, 0, 0), "") + ingest() + chk("нулевая ось без цитаты принята", len(list(VOTES.glob("*.json"))), 1) + chk("перевес за A при 1 ошибке у A и 0 у B", _margins("A", "B"), [-1.0]) + chk("перевес за B зеркален", _margins("B", "A"), [1.0]) + + # 3а. РЕГРЕССИЯ на найденный дефект: `\s` включает перевод строки, и пустое поле утаскивало + # значение соседней строки. Проверяется на обеих ролях — числовой и обосновании. + for f in VOTES.glob("*.json"): + f.unlink() + (ANSW / "tok.txt").write_text( + "Т1-ВЕРНОСТЬ: 2\nТ1-ТЕРМИН: 0\nТ1-ЯЗЫК: 0\nТ1-ФОРМА: 0\nТ1-ПОЧЕМУ:\n" + "Т2-ВЕРНОСТЬ: 0\nТ2-ТЕРМИН: 0\nТ2-ЯЗЫК: 0\nТ2-ФОРМА: 0\nТ2-ПОЧЕМУ:\n", encoding="utf-8") + ingest() + chk("пустое ПОЧЕМУ не утаскивает соседнюю строку", list(VOTES.glob("*.json")), []) + (ANSW / "tok.txt").write_text( + "Т1-ВЕРНОСТЬ:\nТ1-ТЕРМИН: 5\nТ1-ЯЗЫК: 0\nТ1-ФОРМА: 0\nТ1-ПОЧЕМУ: ТЕРМИН «а»\n" + "Т2-ВЕРНОСТЬ: 0\nТ2-ТЕРМИН: 0\nТ2-ЯЗЫК: 0\nТ2-ФОРМА: 0\nТ2-ПОЧЕМУ:\n", encoding="utf-8") + ingest() + chk("пустое число не утаскивает соседнюю строку", list(VOTES.glob("*.json")), []) + (ANSW / "tok.txt").write_text( + "Т1-ВЕРНОСТЬ: 1\nТ1-ТЕРМИН: 0\nТ1-ЯЗЫК: 0\nТ1-ФОРМА: 0\n" + "Т1-ПОЧЕМУ: ВЕРНОСТЬ «первая строка»\n и «вторая строка»\n" + "Т2-ВЕРНОСТЬ: 0\nТ2-ТЕРМИН: 0\nТ2-ЯЗЫК: 0\nТ2-ФОРМА: 0\nТ2-ПОЧЕМУ:\n", encoding="utf-8") + ingest() + got = json.loads((VOTES / "tok.json").read_text(encoding="utf-8"))["Т1"]["why"] + chk("многострочное обоснование взято целиком", "вторая строка" in got, True) + + # 3б. РЕГРЕССИЯ: обоснование обязано НАЗЫВАТЬ каждую ненулевую ось, а не быть просто непустым. + for f in VOTES.glob("*.json"): + f.unlink() + (ANSW / "tok.txt").write_text( + "Т1-ВЕРНОСТЬ: 3\nТ1-ТЕРМИН: 4\nТ1-ЯЗЫК: 0\nТ1-ФОРМА: 0\nТ1-ПОЧЕМУ: ВЕРНОСТЬ «а»\n" + "Т2-ВЕРНОСТЬ: 0\nТ2-ТЕРМИН: 0\nТ2-ЯЗЫК: 0\nТ2-ФОРМА: 0\nТ2-ПОЧЕМУ:\n", encoding="utf-8") + ingest() + chk("ненулевая ось, НЕ названная в обосновании, отвергнута", list(VOTES.glob("*.json")), []) + (ANSW / "tok.txt").write_text( + "Т1-ВЕРНОСТЬ: 3\nТ1-ТЕРМИН: 4\nТ1-ЯЗЫК: 0\nТ1-ФОРМА: 0\n" + "Т1-ПОЧЕМУ: ВЕРНОСТЬ «а» | ТЕРМИН «б»\n" + "Т2-ВЕРНОСТЬ: 0\nТ2-ТЕРМИН: 0\nТ2-ЯЗЫК: 0\nТ2-ФОРМА: 0\nТ2-ПОЧЕМУ:\n", encoding="utf-8") + ingest() + chk("обе ненулевые оси названы — принято", len(list(VOTES.glob("*.json"))), 1) + # 4. Близнец: одинаковая подпись при разном счёте обязана быть поймана. + key["tok"]["Т2"]["sig"] = "aa" + (KEYS / f"{PASS}-KEY.json").write_text(json.dumps(key), encoding="utf-8") + ingest() + import io # noqa: PLC0415 + import contextlib # noqa: PLC0415 + buf = io.StringIO() + with contextlib.redirect_stdout(buf): + controls() + chk("расхождение близнецов поймано", "разошлись на 7" in buf.getvalue(), True) + _dirs, KEYS = sv + + # 5. Холм: на семи одинаковых p поправка обязана умножать наибольший на 7. + chk("Холм монотонен", min(1.0, 0.01 * 7) > min(1.0, 0.01 * 1), True) + print(f"\n{'ОСНАСТКА ЧИСТА' if not bad else f'ПРОВАЛОВ: {bad}'}") + return bad + + +if __name__ == "__main__": + a = sys.argv[1:] or ["--selfcheck"] + if a[0] in ("--emit2", "--ingest2", "--score2", "--controls2", "--position2", "--judges2", + "--axes2", "--agree"): + PASS = "abs2" # noqa: PLW0127 + globals()["PASS"] = "abs2" + a[0] = a[0].replace("2", "") if a[0] != "--agree" else a[0] + fn = {"--selfcheck": lambda: sys.exit(1 if selfcheck() else 0), "--emit": emit, + "--ingest": ingest, "--score": score, "--controls": controls, "--axes": axes, "--position": position, "--judges": judges_agree}.get(a[0]) + fn() if fn else print(__doc__) diff --git a/eval/role_topology/agentjudge.py b/eval/role_topology/agentjudge.py index d972ea28..9274472d 100644 --- a/eval/role_topology/agentjudge.py +++ b/eval/role_topology/agentjudge.py @@ -183,6 +183,49 @@ def record(tok: str, v1: dict, v2: dict, style: str, why: str) -> None: ensure_ascii=False), encoding="utf-8") +ANSWERS = OUT / "aj-answers" + + +def ingest() -> None: + """Разобрать ответы судей из `aj-answers/<токен>.txt` в голоса. $0. + + ⚠ Заведено потому, что иначе ответ агента попадает на диск через МОИ руки, а транскрипция — + это тот самый канал, по которому в третьей редакции потерялись обоснования, а слепое чтение + вообще не персистировалось. Судья пишет файл сам; здесь он только разбирается и проверяется. + Голос с ненулевой осью и пустым обоснованием отвергается (условие 2 амендмента владельца). + """ + import re as _re # noqa: PLC0415 + if not ANSWERS.exists(): + print(f"нет каталога ответов {ANSWERS}") + return + ok = bad = 0 + reasons: dict[str, int] = {} + for f in sorted(ANSWERS.glob("*.txt")): + txt = f.read_text(encoding="utf-8") + v1, v2 = {}, {} + for side, dst in (("В1", v1), ("В2", v2)): + for ax in J.AXES: + m = _re.search(rf"^{side}-{ax}\s*:\s*(\d+)", txt, _re.M) + if m: + dst[ax] = int(m.group(1)) + style = (_re.search(r"^СТИЛЬ\s*:\s*(В1|В2|НИЧЬЯ)", txt, _re.M) or [None, ""])[1] \ + if _re.search(r"^СТИЛЬ\s*:\s*(В1|В2|НИЧЬЯ)", txt, _re.M) else "" + why_m = _re.search(r"^ПОЧЕМУ\s*:\s*(.+)$", txt, _re.M | _re.S) + why = why_m.group(1).strip() if why_m else "" + if len(v1) != len(J.AXES) or len(v2) != len(J.AXES): + bad += 1 + reasons["не разобран формат"] = reasons.get("не разобран формат", 0) + 1 + continue + try: + record(f.stem, v1, v2, style, why) + ok += 1 + except (ValueError, KeyError) as e: # noqa: PERF203 + bad += 1 + k = "нет обоснования" if isinstance(e, ValueError) else "токена нет в ключе" + reasons[k] = reasons.get(k, 0) + 1 + print(f"принято голосов {ok} · отвергнуто {bad} {reasons if reasons else ''}") + + def _margins(kind_filter: str | None = None) -> dict[str, dict[str, list[float]]]: out: dict[str, dict[str, list[float]]] = {} for f in VOTES.glob("*.json"): @@ -242,6 +285,8 @@ if __name__ == "__main__": a = sys.argv[1:] or ["--score"] if a[0] == "--emit": emit((a[1] if len(a) > 1 else "AvF3,BvF3,D_vA,A_lawvB").split(",")) + elif a[0] == "--ingest": + ingest() elif a[0] == "--controls": controls() elif a[0] == "--score": diff --git a/eval/role_topology/bakeoff.py b/eval/role_topology/bakeoff.py index 6ea6b64b..347df33e 100644 --- a/eval/role_topology/bakeoff.py +++ b/eval/role_topology/bakeoff.py @@ -80,7 +80,12 @@ REPS_PER_ORDER = 1 # и печатается, а не подгоняется в момент отказа. CEIL_ARMS = 1.60 CEIL_JUDGE = 3.20 -LED_ARMS = BUY.Ledger("армы Ф2а-2", CEIL_ARMS, ("bo2-*.json",), default_expect=0.03) +# ⚠ ГЛОБ ОБЯЗАН ПОКРЫВАТЬ ВСЕ ТЕГИ, КОТОРЫЕ ЭТА КАССА ОПЛАЧИВАЕТ. Поймано адверсариальным ревью +# 07.08 исполнением: касса глобила только `bo2-*`, а `run_arm3` покупает тегом `bo4-*`, поэтому +# $0.29309 армов ТРЕТЬЕЙ редакции прошли мимо потолка — `afford()` считал их несуществующими. +# Это ровно тот класс дефекта, который шапка `buy.py` объявляет починенным, и он вернулся через +# новый префикс. Правило: заводишь новый тег — добавляешь его в глоб кассы В ТОМ ЖЕ коммите. +LED_ARMS = BUY.Ledger("армы Ф2а-2", CEIL_ARMS, ("bo2-*.json", "bo4-*.json"), default_expect=0.03) LED_JUDGE = BUY.Ledger("судейство Ф2а-2", CEIL_JUDGE, ("jv2-*.json",), default_expect=0.008) # АРМЫ ВТОРОЙ РЕДАКЦИИ (07.08). Первая редакция отклонялась от промта в четырёх местах, и все diff --git a/eval/role_topology/buy.py b/eval/role_topology/buy.py index 320fabf9..5be85be0 100644 --- a/eval/role_topology/buy.py +++ b/eval/role_topology/buy.py @@ -86,6 +86,44 @@ def priced(model: str, us: dict) -> float: us["reasoning_tokens"], us["total_tokens"]), 6) +ZONE = Path(__file__).resolve().parent + + +def _refuse_unfrozen_caller() -> None: + """Отказать в ПОКУПКЕ, если вызов пришёл из кода вне зоны полигона. + + ⚠ Заведено 07.08 по собственной находке, повторённой ТРИЖДЫ: покупки делались скриптами из + временного каталога сессии и встроенным питоном из командной строки. Такие траты не + воспроизводимы из репозитория и не попадают под пре-рег-фриз — это ровно тот дефект, за + который снята первая редакция («$2.57 из $2.62 потрачены незафиксированным кодом»). + Дисциплина словами не держится: за один пак я нарушил её три раза. Теперь держится кассой. + + Проверяется ФАЙЛ ВЫЗЫВАЮЩЕГО, а не текущий: кэш и своды из любого места читать можно, + отказ касается только денег. Обход намеренно оставлен явным и громким — TM_ALLOW_UNFROZEN=1 + в окружении, чтобы разовая отладка требовала осознанного действия и была видна в истории. + """ + import inspect # noqa: PLC0415 + import os # noqa: PLC0415 + if os.environ.get("TM_ALLOW_UNFROZEN") == "1": + return + for fr in inspect.stack()[1:]: + # ⚠ НЕ-ФАЙЛ проверяется ПЕРВЫМ, до сравнения каталога. Первая версия сравнивала каталог + # раньше, и `Path("").resolve()` при запуске ИЗ каталога зоны давала parent == ZONE, + # то есть `python -c` из самого каталога пака проходил гард насквозь — именно тот способ + # запуска, ради которого гард и заведён. Поймано адверсариальным ревью исполнением 07.08. + if fr.filename.startswith("<") or not Path(fr.filename).is_file(): + raise SystemExit(f"⛔ покупка из НЕ-ФАЙЛА ({fr.filename}) запрещена: " + "встроенный питон из командной строки не воспроизводим из репозитория") + p = Path(fr.filename).resolve() + if p.parent == ZONE: # свой же модуль в цепочке — пропускаем + continue + if p.suffix != ".py": + raise SystemExit(f"⛔ покупка из НЕ-ФАЙЛА ({fr.filename}) запрещена") + raise SystemExit(f"⛔ покупка из кода вне зоны полигона запрещена: {p}\n" + f" перенеси скрипт в {ZONE} и закоммить пре-рег-фризом") + return + + def purchase(led: Ledger, tag: str, model: str, client, kw: dict, **extra) -> dict: """Один платный вызов под кассой. Кэш читается ПЕРВЫМ, гард — перед покупкой. @@ -95,6 +133,7 @@ def purchase(led: Ledger, tag: str, model: str, client, kw: dict, **extra) -> di f = OUT / f"{tag}.json" if f.exists(): return json.loads(f.read_text(encoding="utf-8")) + _refuse_unfrozen_caller() ok, why = led.afford() if not ok: print(why)