278 lines
19 KiB
Python
278 lines
19 KiB
Python
#!/usr/bin/env python3
|
||
"""ВТОРОЕ ЧТЕНИЕ: СКОЛЬКО В ПОРОГЕ ОТ ПРИБОРА, А СКОЛЬКО ОТ ТЕКСТА. $0.
|
||
|
||
⚠ ЗАЧЕМ. У всех наших «неразличимо» до сих пор не было ПАСПОРТА РАЗРЕШЕНИЯ: порог считался по
|
||
разбросу парных разностей, но что в этом разбросе — расхождение ТЕКСТОВ или расхождение ЧИТАТЕЛЕЙ —
|
||
не мерил никто. Два чтения одних и тех же пакетов разделяют это ровно и без моделей: тексты у обоих
|
||
кругов побайтно одни, значит всё, чем круги отличаются, есть читатель.
|
||
|
||
РАЗЛОЖЕНИЕ, объявленное пре-регом Д33.2 ДО чисел. Для пары армов (a,b) и главы u парная разность
|
||
мест `D_r(u) = место_r(a,u) − место_r(b,u)`, где r — круг. Модель `D_r = T + E_r`: общий текстовый
|
||
эффект T (у кругов один, тексты те же) плюс независимый читательский шум E_r. Тогда
|
||
|
||
Var(D1) = σ²_T + σ²_E Var(D1 − D2) = 2·σ²_E
|
||
⇒ ДОЛЯ ПРИБОРА = σ²_E / Var(D1) = Var(D1 − D2) / (2·Var(D1))
|
||
|
||
Доля близка к 1 — порог фазы есть почти чистый шум чтения, и «неразличимо» означает «прибор слеп».
|
||
Доля близка к 0 — порог несёт текст, и «неразличимо» кое-что значит.
|
||
|
||
⛔⛔ ЧТО ИМЕННО РАЗДЕЛЯЕТ ЭТОТ ПРИБОР — ИСПРАВЛЕНО 23.08 ПО ВОПРОСУ ВЛАДЕЛЬЦА. Первая редакция этой
|
||
шапки утверждала «оба круга — ОДНО читательское семейство (`fable-5`)». **ЭТО БЫЛО НЕВЕРНО, и я
|
||
написал это НЕ ПРОВЕРИВ.** Круг 1 всех панелей записан как `claude-fable-5` (`READERS-*.json`,
|
||
решение владельца 20.08 «отдадим всё судейство фаблу»), а мои читатели ушли на **`claude-opus-5`**:
|
||
суб-агент наследует модель сессии, а я не передал переопределения. Доказано транскриптами
|
||
суб-агентов (`agent-*.jsonl`, поле `model`), а не записью о намерении.
|
||
|
||
⇒ `E_r` в разложении ниже есть НЕ читательский шум ОДНОГО семейства, а **цена ПОЛНОЙ СМЕНЫ
|
||
семейства** `fable-5 → opus-5`. Это не мусор и по-своему сильнее: два РАЗНЫХ семейства, сошедшихся
|
||
на медиане Спирмена +0.84, — более требовательная проверка, чем повтор одним и тем же. Но
|
||
объявленной метрики «сколько в пороге ОТ ПРИБОРА» это НЕ даёт: внутрисемейный разброс остаётся
|
||
НЕ ЗАМЕРЕННЫМ, и паспорт разрешения по-прежнему без своего числа.
|
||
|
||
⚠ И прежняя оговорка в силе, только сильнее: согласие двух МАШИННЫХ семейств всё равно молчит про
|
||
ВКУС. Ось ВЕРНОСТИ у владельца разошлась с прибором радикально (Д30) — второе чтение этого не
|
||
трогает вовсе.
|
||
|
||
⚠ И вторая: обёртку запуска ПЕРВОГО круга не хранит ни один артефакт (Д33.4). Значит в разницу
|
||
кругов входит не только читатель, но и неизвестная разница обёрток. Направление вклада неизвестно.
|
||
|
||
Запуск: vtoroe.py --tag=vendor2 [--anchor=RN] [--drop=uid8,uid8]
|
||
vtoroe.py --selftest
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import importlib.util
|
||
import json
|
||
import math
|
||
import re
|
||
import statistics as st
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
REPO = Path("/home/ubuntu/projects/textmachine")
|
||
ZONE = Path(__file__).resolve().parent
|
||
for d in ("dovodka", "editor_tier", "tenant_panel", "role_topology", "bank_arbitration"):
|
||
sys.path.insert(0, str(REPO / "eval" / d))
|
||
|
||
|
||
def _load(name: str, path: Path):
|
||
spec = importlib.util.spec_from_file_location(name, path)
|
||
mod = importlib.util.module_from_spec(spec)
|
||
sys.modules[name] = mod
|
||
spec.loader.exec_module(mod)
|
||
return mod
|
||
|
||
|
||
R = _load("rol_vt", ZONE / "rol.py") # разбор порядка и раскладки — у него, второго не пишем
|
||
CH = R.CH
|
||
ZS = _load("zsud_vt", ZONE / "zsud.py") # знаковый тест — один на зону
|
||
OUT = R.OUT
|
||
READ = R.READ_DIR
|
||
|
||
|
||
def ranks_of(tag: str, p: str, ansdir: str) -> dict:
|
||
"""{uid8: {арм: место}} для одного круга. Глава без разобранного порядка выпадает ВСЛУХ."""
|
||
out, bad = {}, []
|
||
for kf in sorted((OUT / "blind-keys-rol").glob(f"rol-KEY-{tag}-*.json")):
|
||
uid8 = kf.stem.split(f"{tag}-")[1]
|
||
key = json.loads(kf.read_text(encoding="utf-8"))
|
||
if p not in key:
|
||
continue
|
||
lay = key[p]["1"]["метки"]
|
||
af = (READ / ansdir) / f"ОТВЕТ-{p}-{tag}-{uid8}.md"
|
||
if not af.exists():
|
||
bad.append((uid8, f"ответа нет в {ansdir}/"))
|
||
continue
|
||
txt = af.read_text(encoding="utf-8", errors="replace")
|
||
places = CH._ranks(R._order_of(txt, set(lay))) # noqa: SLF001
|
||
if sorted(places) != sorted(lay):
|
||
bad.append((uid8, f"порядок покрывает {len(places)} из {len(lay)} меток"))
|
||
continue
|
||
out[uid8] = {lay[lab]: pos for lab, pos in places.items()}
|
||
for uid8, why in bad:
|
||
print(f" ⚠ {ansdir}/{uid8}: {why}")
|
||
return out
|
||
|
||
|
||
def spearman(a: list, b: list) -> float:
|
||
"""Пирсон по местам. Места уже средние для связок (`chtenie._ranks`), поэтому это и есть
|
||
Спирмен с поправкой на связки — отдельной формулы не нужно."""
|
||
n = len(a)
|
||
if n < 3:
|
||
return float("nan")
|
||
ma, mb = st.mean(a), st.mean(b)
|
||
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
|
||
den = math.sqrt(sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b))
|
||
return num / den if den else float("nan")
|
||
|
||
|
||
def contrasts(rk: dict, uids: list, arms: list, anchor: str) -> dict:
|
||
"""{арм: (разрыв, порог, знаковый p)} против якоря — форма порога та же, что в своде."""
|
||
out = {}
|
||
for a in arms:
|
||
if a == anchor:
|
||
continue
|
||
d = [rk[u][a] - rk[u][anchor] for u in uids]
|
||
out[a] = (st.mean(d), 2.8 * st.pstdev(d) / len(d) ** 0.5, ZS._sign_p(d)) # noqa: SLF001
|
||
return out
|
||
|
||
|
||
def verdict(gap: float, thr: float, p: float) -> str:
|
||
"""Конъюнкция пре-рега Д17.4: порог И знаковый p<0.05. Иначе — «в пределах»."""
|
||
return "РАЗЛИЧИМ" if abs(gap) > thr and p < 0.05 else "в пределах"
|
||
|
||
|
||
def report(tag: str = "vendor2", p: str = "en", anchor: str = "RN", drop: tuple = (),
|
||
da: str = "r1", db: str = "r2") -> int:
|
||
r1, r2 = ranks_of(tag, p, da), ranks_of(tag, p, db)
|
||
uids = [u for u in sorted(set(r1) & set(r2)) if u not in drop]
|
||
if not uids:
|
||
raise SystemExit("⛔ нет глав, прочитанных ОБОИМИ кругами")
|
||
arms = sorted(r1[uids[0]])
|
||
print(f"\n=== ВТОРОЕ ЧТЕНИЕ {tag}, пара {p} ===")
|
||
print(f" глав в обоих кругах: {len(uids)} (в круге 1 всего {len(r1)}, в круге 2 {len(r2)})")
|
||
print(f" армов {len(arms)} · якорь {anchor}"
|
||
+ (f" · ВЫБРОШЕНЫ: {', '.join(drop)}" if drop else ""))
|
||
|
||
# ── (i) СОГЛАСИЕ ПОРЯДКОВ ────────────────────────────────────────────────────────────────
|
||
print(f"\n(i) СОГЛАСИЕ ПОРЯДКОВ по главе (Спирмен, {len(arms)} армов):")
|
||
rho = []
|
||
for u in uids:
|
||
r = spearman([r1[u][a] for a in arms], [r2[u][a] for a in arms])
|
||
rho.append(r)
|
||
print(f" {u}: ρ = {r:+.2f}")
|
||
print(f" медиана ρ = {st.median(rho):+.2f} · среднее {st.mean(rho):+.2f} · "
|
||
f"минимум {min(rho):+.2f} · максимум {max(rho):+.2f}")
|
||
print(f" ⚠ ρ=0 значит «второе чтение не воспроизводит первое НИКАК»; ρ=1 — точная копия")
|
||
|
||
# ── (iii) СКОЛЬКО В ПОРОГЕ ОТ ПРИБОРА ────────────────────────────────────────────────────
|
||
print("\n(iii) РАЗЛОЖЕНИЕ ПОРОГА: доля ЧИТАТЕЛЯ в дисперсии парной разности")
|
||
shares, rows = [], []
|
||
for i, a in enumerate(arms):
|
||
for b in arms[i + 1:]:
|
||
d1 = [r1[u][a] - r1[u][b] for u in uids]
|
||
d2 = [r2[u][a] - r2[u][b] for u in uids]
|
||
v1 = st.pvariance(d1)
|
||
ve = st.pvariance([x - y for x, y in zip(d1, d2)]) / 2
|
||
sh = ve / v1 if v1 else float("nan")
|
||
rows.append((f"{a}−{b}", v1, ve, sh))
|
||
if v1:
|
||
shares.append(min(sh, 2.0))
|
||
rows.sort(key=lambda x: -x[1])
|
||
print(f" {'пара':14s}{'Var(D1)':>10s}{'σ²читателя':>12s}{'доля':>8s}")
|
||
for name, v1, ve, sh in rows[:8]:
|
||
print(f" {name:14s}{v1:10.2f}{ve:12.2f}{sh:8.2f}")
|
||
print(f" … всего пар {len(rows)}")
|
||
print(f" ⭐ МЕДИАННАЯ ДОЛЯ ЧИТАТЕЛЯ = {st.median(shares):.2f} "
|
||
f"(среднее {st.mean(shares):.2f}, пар с долей ≥1.0: "
|
||
f"{sum(1 for x in shares if x >= 1.0)} из {len(shares)})")
|
||
print(" ⚠ доля 1.0 = читательский шум ОДИН объясняет весь наблюдённый разброс, текстового "
|
||
"вклада прибор не видит; доля >1.0 = круги расходятся СИЛЬНЕЕ, чем разошлись бы\n"
|
||
" независимые (анти-согласие), и порог тогда не мерит вообще ничего")
|
||
|
||
# ── (ii) ПЕРЕ-СЧЁТ КОНТРАСТОВ И ПЕРЕВЁРНУТЫЕ ВЕРДИКТЫ ────────────────────────────────────
|
||
c1, c2 = contrasts(r1, uids, arms, anchor), contrasts(r2, uids, arms, anchor)
|
||
print(f"\n(ii) КОНТРАСТЫ ПРОТИВ ЯКОРЯ {anchor} — оба круга на ОДНИХ {len(uids)} главах:")
|
||
print(f" {'арм':5s}{'круг1 разрыв':>13s}{'порог':>7s}{'p':>8s} {'вердикт1':11s}"
|
||
f"{'круг2 разрыв':>13s}{'порог':>7s}{'p':>8s} {'вердикт2':11s}")
|
||
flips = []
|
||
for a in sorted(c1, key=lambda x: c1[x][0]):
|
||
g1, t1, p1 = c1[a]
|
||
g2, t2, p2 = c2[a]
|
||
v1, v2 = verdict(g1, t1, p1), verdict(g2, t2, p2)
|
||
if v1 != v2:
|
||
flips.append((a, v1, v2))
|
||
print(f" {a:5s}{g1:+13.2f}{t1:7.2f}{p1:8.4f} {v1:11s}"
|
||
f"{g2:+13.2f}{t2:7.2f}{p2:8.4f} {v2:11s}{' ⛔ ПЕРЕВЁРНУТ' if v1 != v2 else ''}")
|
||
print(f"\n ПЕРЕВЁРНУТЫХ ВЕРДИКТОВ: {len(flips)} из {len(c1)}"
|
||
+ ("" if not flips else " — " + ", ".join(f"{a}: {x}→{y}" for a, x, y in flips)))
|
||
return 0
|
||
|
||
|
||
def vkus(tag: str = "vendor2", p: str = "en", drop: tuple = (),
|
||
da: str = "r1", db: str = "r2", na: str = "fable-5", nb: str = "opus-5") -> int:
|
||
"""СРАВНЕНИЕ ДВУХ СУДЕЙСКИХ СЕМЕЙСТВ — то, чего норме П-1 не хватало с 20.08.
|
||
|
||
⚠ Заведено 23.08 по слову владельца: «раз уж ты пробежал какое-то судейство другим агентом,
|
||
заодно можно и сравнить будет их». До этого дня всё судейство фазы вело ОДНО семейство
|
||
(`fable-5`), и общий ВКУС семейства нельзя было отделить от качества перевода в принципе —
|
||
ограничение записано в `READERS-arch2.json` как ⚠_ограничение. Круг 2 дал второе семейство
|
||
(`opus-5`) — пусть и по моей ошибке, а не по замыслу.
|
||
|
||
⛔ ЧТО МЕРИТСЯ И ЧТО НЕТ. Места КОМПОЗИЦИОННЫ: если один арм поднялся, другой обязан опуститься,
|
||
и сумма мест по главе константна. Значит «систематический сдвиг арма» есть утверждение
|
||
ОТНОСИТЕЛЬНОЕ — «семейства по-разному упорядочивают», — а не «одно строже другого». Абсолютной
|
||
строгости этот прибор не видит и видеть не может.
|
||
"""
|
||
r1, r2 = ranks_of(tag, p, da), ranks_of(tag, p, db)
|
||
uids = [u for u in sorted(set(r1) & set(r2)) if u not in drop]
|
||
arms = sorted(r1[uids[0]])
|
||
print(f"\n=== ВКУС ДВУХ СЕМЕЙСТВ, {tag}: {na} ({da}/) против {nb} ({db}/) ===")
|
||
print(f" глав {len(uids)} · армов {len(arms)}\n")
|
||
print(f" {'арм':6s}{na[:7]:>8s}{nb[:7]:>8s}{'сдвиг':>8s}{'глав ↑':>8s}{'глав ↓':>8s}{'p':>9s} вывод")
|
||
rows = []
|
||
for a in arms:
|
||
d = [r2[u][a] - r1[u][a] for u in uids] # >0 — opus ставит НИЖЕ (место больше)
|
||
m = st.mean(d)
|
||
nz = [x for x in d if x]
|
||
pv = ZS._sign_p(d) # noqa: SLF001
|
||
rows.append((a, st.mean([r1[u][a] for u in uids]), st.mean([r2[u][a] for u in uids]),
|
||
m, sum(1 for x in nz if x < 0), sum(1 for x in nz if x > 0), pv))
|
||
for a, m1, m2, m, up, dn, pv in sorted(rows, key=lambda x: x[3]):
|
||
mark = f"⛔ {nb} судит ИНАЧЕ" if pv < 0.05 else ""
|
||
print(f" {a:6s}{m1:8.2f}{m2:8.2f}{m:+8.2f}{up:8d}{dn:8d}{pv:9.4f} {mark}")
|
||
sig = [r for r in rows if r[6] < 0.05]
|
||
print(f"\n армов, чьё место семейства ставят РАЗЛИЧИМО по-разному: {len(sig)} из {len(arms)}"
|
||
+ ("" if not sig else " — " + ", ".join(r[0] for r in sig)))
|
||
print(f" ⚠ сдвиг >0 значит «{nb} ставит арм НИЖЕ, чем {na}»; сумма сдвигов по построению ≈0")
|
||
return 0
|
||
|
||
|
||
def cmd_selftest() -> int:
|
||
bad = 0
|
||
|
||
def ck(n: str, ok: bool, d: str = "") -> None:
|
||
nonlocal bad
|
||
bad += not ok
|
||
print(f"[{'OK ' if ok else 'ПРОВАЛ'}] {n}" + (f" {d}" if d else ""))
|
||
|
||
ck("Спирмен: точная копия даёт +1", abs(spearman([1, 2, 3, 4], [1, 2, 3, 4]) - 1) < 1e-9)
|
||
ck("Спирмен: обратный порядок даёт −1", abs(spearman([1, 2, 3, 4], [4, 3, 2, 1]) + 1) < 1e-9)
|
||
ck("Спирмен: несвязанные ~0", abs(spearman([1, 2, 3, 4], [2, 1, 4, 3])) < 0.7)
|
||
# ⛔ РАЗЛОЖЕНИЕ ПРОВЕРЯЕТСЯ НА ЗАВЕДОМО ИЗВЕСТНОМ ВХОДЕ, а не на живых данных: иначе «доля 0.9»
|
||
# нечем отличить от арифметической ошибки. Два синтетических предела и один смешанный.
|
||
same = [3, -1, 2, 0, 4, -2]
|
||
ve = st.pvariance([x - y for x, y in zip(same, same)]) / 2
|
||
ck("предел А: круги СОВПАДАЮТ → доля читателя 0", abs(ve) < 1e-12, f"σ²={ve}")
|
||
# ⚠ ПЕРВАЯ РЕДАКЦИЯ ЭТОГО ГЕЙТА БЫЛА НЕГОДНОЙ и упала при первом же прогоне: «независимыми»
|
||
# я взял вектор и его ОТРИЦАНИЕ, то есть анти-корреляцию, и получил долю 2.00 вместо 1.00.
|
||
# Ошибка полезная: она показала, что доля БОЛЬШЕ единицы — законный исход и означает не
|
||
# «шум объясняет всё», а «читатели расходятся СИЛЬНЕЕ, чем разошлись бы независимо».
|
||
a1, a2 = [1, 1, -1, -1], [1, -1, 1, -1] # ортогональны: ковариация ровно 0
|
||
sh = (st.pvariance([x - y for x, y in zip(a1, a2)]) / 2) / st.pvariance(a1)
|
||
ck("предел Б: круги НЕЗАВИСИМЫ → доля читателя = 1", abs(sh - 1) < 1e-9, f"доля={sh:.2f}")
|
||
a3 = [-1, -1, 1, 1] # ровно противоположный первому
|
||
sh2 = (st.pvariance([x - y for x, y in zip(a1, a3)]) / 2) / st.pvariance(a1)
|
||
ck("предел В: круги ПРОТИВОПОЛОЖНЫ → доля 2 (законный исход, не баг)",
|
||
abs(sh2 - 2) < 1e-9, f"доля={sh2:.2f}")
|
||
ck("конъюнкция: порог пройден, p велик → в пределах", verdict(3.0, 2.0, 0.30) == "в пределах")
|
||
ck("конъюнкция: p мал, порог не пройден → в пределах", verdict(1.0, 2.0, 0.01) == "в пределах")
|
||
ck("конъюнкция: оба условия → РАЗЛИЧИМ", verdict(3.0, 2.0, 0.01) == "РАЗЛИЧИМ")
|
||
print(f"\n{'ПРИБОР ГОДЕН' if not bad else f'ПРОВАЛОВ: {bad}'}")
|
||
return bad
|
||
|
||
|
||
if __name__ == "__main__":
|
||
a = sys.argv[1:] or ["--selftest"]
|
||
if a[0] == "--selftest":
|
||
sys.exit(1 if cmd_selftest() else 0)
|
||
_tag = next((x.split("=", 1)[1] for x in a if x.startswith("--tag=")), "vendor2")
|
||
_anch = next((x.split("=", 1)[1] for x in a if x.startswith("--anchor=")), "RN")
|
||
_drop = tuple(next((x.split("=", 1)[1].split(",") for x in a if x.startswith("--drop=")), []))
|
||
_da = next((x.split("=", 1)[1] for x in a if x.startswith("--a=")), "r1")
|
||
_db = next((x.split("=", 1)[1] for x in a if x.startswith("--b=")), "r2")
|
||
_na = next((x.split("=", 1)[1] for x in a if x.startswith("--na=")), "fable-5")
|
||
_nb = next((x.split("=", 1)[1] for x in a if x.startswith("--nb=")), "opus-5")
|
||
if "--vkus" in a:
|
||
sys.exit(vkus(_tag, "en", _drop, _da, _db, _na, _nb))
|
||
sys.exit(report(_tag, "en", _anch, _drop, _da, _db))
|