| """Corsa di conferma. §6–§7: tabelle dalle diagnosi (analysis/diag.json). Uso: python3 analysis/diag_report.py > analysis/diag.md""" |
| import json |
| from collections import Counter |
| from pathlib import Path |
|
|
| import load as LD |
|
|
| OUT = Path(__file__).resolve().parent |
| d = json.load(open(OUT / "diag.json")) |
| rows = {(r["L"], r["pol"], r["qid"]): r for r in LD.load_results()} |
| SUM = {} |
|
|
|
|
| def P(*a): |
| print(*a) |
|
|
|
|
| def short(st): |
| return "; ".join(x.replace("toccato ", "tocc. ") for x in st) |
|
|
|
|
| P("## 6a. Convenzione dei round: controllo di validità preregistrato (i punteggi restano quelli ufficiali, nessuna rivalutazione)\n") |
| P("Nel banco \"the tool results for round N\" è l'uscita dello strumento che **precede** il messaggio utente " |
| "\"Round N: Guess …\" (verificato su tutte le 100 domande: la risposta ufficiale si ricalcola esattamente così). " |
| "La lettura naturale per il modello è l'uscita che **segue** \"Round N\" (la query fatta dopo il feedback del " |
| "round N). Domande in cui le due letture danno risposte diverse = \"distinguenti\".\n") |
| P("| insieme | politica | distinguenti giuste | non distinguenti giuste | risposte = lettura alternativa sulle distinguenti |") |
| P("|---|---|---|---|---|") |
| for L in ("64k", "128k", "unite"): |
| R = [v for v in d.values() if L == "unite" or v["L"] == L] |
| dis = [v for v in R if v["conv_distinguishes"]] |
| nd = [v for v in R if not v["conv_distinguishes"]] |
| for p in LD.POLS: |
| alt = sum(1 for v in dis if v[p]["pred"] == v["gold_alt"]) |
| P(f"| {L} | {p} | {sum(v[p]['ok'] for v in dis)}/{len(dis)} | {sum(v[p]['ok'] for v in nd)}/{len(nd)} | " |
| f"{alt}/{len(dis)} |") |
| SUM.setdefault("conv", {}).setdefault(L, {})[p] = { |
| "dis_ok": sum(v[p]["ok"] for v in dis), "n_dis": len(dis), "nd_ok": sum(v[p]["ok"] for v in nd), |
| "n_nd": len(nd), "alt": alt} |
| P("") |
| P("Dove D ha cercato (giornale del proxy: richiami che hanno restituito o interrogato il messaggio), tutte le 100 " |
| "domande:\n") |
| ce, ca = Counter(), Counter() |
| for v in d.values(): |
| for x in v["D_diag"]["ev_in_final"]: |
| ce[x.split(" (")[0]] += 1 |
| for x in v["D_diag"]["alt_in_final"]: |
| ca[x.split(" (")[0]] += 1 |
| P("| messaggio | vivo nel prompt finale | letto intero | toccato (risultato o interrogazione per id) | assente |") |
| P("|---|---|---|---|---|") |
| P(f"| prova del banco (prima di \"Round N\") | {ce['vivo']} | {ce['letto intero']} | {ce['toccato']} | {ce['assente']} |") |
| P(f"| lettura alternativa (dopo \"Round N\") | {ca['vivo']} | {ca['letto intero']} | {ca['toccato']} | {ca['assente']} |") |
| P("") |
|
|
| |
| for L in ("128k", "64k"): |
| P(f"## 6b. Discordanti D/B a {L}\n") |
| P("| qid | tipo | vince | gold | gold alt. | distingue | A | D | B | T | D: giri | D: richiami | D: chiusure | " |
| "D: cambi segm. / note | D: prova nel prompt finale | D: lettura alt. | B: compattazioni | B: prova nel prompt finale | " |
| "B: id nel riassunto |") |
| P("|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|") |
| disc = [v for v in d.values() if v["L"] == L and v["D"]["ok"] != v["B"]["ok"]] |
| disc.sort(key=lambda v: (v["D"]["ok"], int(v["qid"].split("_")[0]))) |
| for v in disc: |
| D, B = v["D_diag"], v["B_diag"] |
| clo = [c[1] for c in D["close"] if c[0] == "final"] or ["—"] |
| P(f"| {v['qid']} | {v['qt']} | {'D' if v['D']['ok'] else 'B'} | {v['gold']} | {v['gold_alt']} | " |
| f"{'sì' if v['conv_distinguishes'] else 'no'} | {v['A']['pred']} | {v['D']['pred']} | {v['B']['pred']} | " |
| f"{v['T']['pred']} | {D['rounds']} | {D['recall_n']} | {', '.join(clo)} | {D['switches']} / " |
| f"{','.join(D['notes_finish']) or '—'} | {short(D['ev_in_final'])} | {short(D['alt_in_final'])} | " |
| f"{B['compactions']} | {short(B['ev_in_final'])} | {'sì' if B['target_in_summary'] else 'no'} |") |
| P("") |
|
|
| |
| bw = [v for v in disc if v["B"]["ok"]] |
| dw = [v for v in disc if v["D"]["ok"]] |
|
|
| def b_has_ev(v): |
| return all(s == "vivo" or s.startswith("nel riassunto intero") for s in v["B_diag"]["ev_in_final"]) |
|
|
| def d_alt(v): |
| return v["conv_distinguishes"] and v["D"]["pred"] == v["gold_alt"] |
|
|
| def d_bad(v): |
| r = rows[(L, "D", v["qid"])] |
| return r["empty"] or r["trunc"] or r["resid"] or r["invalid"] |
|
|
| def b_bad(v): |
| r = rows[(L, "B", v["qid"])] |
| return r["empty"] or r["trunc"] or r["resid"] or r["invalid"] |
|
|
| def closed(v): |
| return any(c[0] == "final" for c in v["D_diag"]["close"]) |
|
|
| def ev_seen(v): |
| return all(s in ("vivo", "letto intero") for s in v["D_diag"]["ev_in_final"]) |
| causes = [ |
| ("D risponde secondo la lettura alternativa dei round (domanda distinguente, risposta D = gold alternativo)", |
| sum(d_alt(v) for v in bw), sum(d_alt(v) for v in dw)), |
| ("B senza la prova nel prompt finale (né viva né intera nel riassunto): risposta non sostenuta dai dati", |
| sum(not b_has_ev(v) for v in bw), sum(not b_has_ev(v) for v in dw)), |
| ("B risponde \"assente\" (0 / no) e la risposta giusta è negativa", |
| sum(v["B"]["neg_answer"] and v["neg"] for v in bw), sum(v["D"]["neg_answer"] and v["neg"] for v in dw)), |
| ("Ricerca di D chiusa dal proxy (round_limit / spazio / no_room) prima della risposta", |
| sum(closed(v) for v in bw), sum(closed(v) for v in dw)), |
| ("Prova del banco vista per intero da D (viva o letta intera)", |
| sum(ev_seen(v) for v in bw), sum(ev_seen(v) for v in dw)), |
| ("Risposta non valida / troncata / con chiamate residue (D nelle vittorie di B; B nelle vittorie di D)", |
| sum(d_bad(v) for v in bw), sum(b_bad(v) for v in dw)), |
| ] |
| P(f"### Cause candidate a {L} (una domanda può avere più cause)\n") |
| P(f"| causa | casi fra le {len(bw)} vinte da B | casi fra le {len(dw)} vinte da D |") |
| P("|---|---|---|") |
| for c, a, b in causes: |
| P(f"| {c} | {a} | {b} |") |
| P("") |
| SUM.setdefault("causes", {})[L] = {"B_wins": len(bw), "D_wins": len(dw), "causes": causes} |
|
|
| |
| P("## 6c. Chiusure della ricerca di D e risultato (tutte le domande)\n") |
| P("| lunghezza | chiusura | domande | D giuste |") |
| P("|---|---|---|---|") |
| for L in ("64k", "128k"): |
| c = Counter() |
| ok = Counter() |
| for v in d.values(): |
| if v["L"] != L: |
| continue |
| k = ",".join(sorted({x[1] for x in v["D_diag"]["close"] if x[0] == "final"})) or "nessuna (risposta spontanea)" |
| c[k] += 1 |
| ok[k] += v["D"]["ok"] |
| for k in sorted(c): |
| P(f"| {L} | {k} | {c[k]} | {ok[k]} |") |
| P("") |
|
|
| |
| P("## 7. A (finestra piena) a 128k\n") |
| P("| lunghezza | politica | ragionamento al budget (≥3072 generati nella risposta) | troncate | non valide | " |
| "TTFT mediano risposta (s) | giuste non distinguenti | giuste distinguenti |") |
| P("|---|---|---|---|---|---|---|---|") |
| for L in ("64k", "128k"): |
| for p in LD.POLS: |
| rs = [r for k, r in rows.items() if k[0] == L and k[1] == p] |
| bud, tt = 0, [] |
| for r in rs: |
| ec = LD.load_engine_calls(r["dir"]) |
| a = [c for c in ec if c["kind"] in ("answer", "final", "round")][-1] |
| bud += (a.get("completion_tokens") or 0) >= 3072 |
| tt.append(a.get("ttft_s") or 0) |
| tt.sort() |
| cv = SUM["conv"][L][p] |
| P(f"| {L} | {p} | {bud}/50 | {sum(r['trunc'] for r in rs)} | {sum(r['invalid'] for r in rs)} | " |
| f"{tt[len(tt) // 2]:.1f} | {cv['nd_ok']}/{cv['n_nd']} | {cv['dis_ok']}/{cv['n_dis']} |") |
| P("") |
| P("A a 128k, domande non distinguenti sbagliate:\n") |
| for v in d.values(): |
| if v["L"] == "128k" and not v["conv_distinguishes"] and not v["A"]["ok"]: |
| r = rows[("128k", "A", v["qid"])] |
| P(f"- {v['qid']} ({v['qt']}): gold {v['gold']}, A {v['A']['pred']}, troncata {r['trunc']}, " |
| f"finish {r['finish']}, D {v['D']['pred']}, B {v['B']['pred']}") |
| P("") |
| (OUT / "diag_summary.json").write_text(json.dumps(SUM, indent=1, default=str)) |
|
|
