| |
| """Choose decision thresholds from validation answers. |
| |
| Replays a validation set through the engine and picks the thresholds that |
| meet the experiment's bars, printing a decisions.yaml fragment: |
| |
| turn.tools.load_at the P(true) that maximizes F-beta with beta=2 |
| across loadable tools (a missed tool costs a |
| round trip, an extra one costs schema bytes) |
| turn.guides.omit_below and turn.guides.confidence_floor |
| the pair that omits the most units while keeping |
| omission precision at or above --omission-precision |
| (an omitted unit that was needed is a silent drop) |
| request.load_at the unit-rank score that maximizes F-beta over |
| the tools each request_tools need was for (the |
| tools the turn used after it, and those the |
| judge scored 3 or more) |
| turn.skills.preload_at the lowest top score that preloads the most turns |
| while the preloaded skill was judged relevant |
| (skill_scores of 3 or more) at or above |
| --preload-precision; a wrong preload steers the |
| whole turn |
| |
| Each is reported with its support; tools also with the expected calibration |
| error, and the tool threshold also per host (coordinator turns and worker |
| legs), so a host that would want a different threshold shows up. Rows are |
| training rows (rows.py) and every question is the one the row's turn offered. |
| |
| Usage: calibrate.py --corpus C --examples FILE [--engine PATH] [--beta 2.0] |
| [--omission-precision 0.97] [--preload-precision 0.8] |
| """ |
|
|
| import argparse |
| import collections |
| import os |
| import sys |
|
|
| sys.path.insert(0, os.path.dirname(__file__)) |
| import rows as rowfile |
| from corpus import Corpus |
| from replay_eval import Engine, ece, option_answer |
|
|
|
|
| def fbeta(tp, fp, fn, beta): |
| if tp == 0: |
| return 0.0 |
| p = tp / (tp + fp) |
| r = tp / (tp + fn) |
| b2 = beta * beta |
| return (1 + b2) * p * r / (b2 * p + r) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--corpus", required=True) |
| ap.add_argument("--examples", required=True) |
| ap.add_argument("--engine", default=os.environ.get("LYCAON_DECIDE_ENGINE"), help="a pw-decide launcher: `pw-decide serve --model ... --head turn-load=...` (default $LYCAON_DECIDE_ENGINE)") |
| ap.add_argument("--beta", type=float, default=2.0) |
| ap.add_argument("--omission-precision", type=float, default=0.97) |
| ap.add_argument("--preload-precision", type=float, default=0.8) |
| args = ap.parse_args() |
| if not args.engine: |
| ap.error("--engine (or LYCAON_DECIDE_ENGINE) must name a pw-decide launcher") |
|
|
| corpus = Corpus.load(args.corpus) |
| examples = rowfile.load(args.examples) |
| tool_pairs = [] |
| guide_pairs = [] |
| skill_tops = [] |
| request_pairs = [] |
| tool_cards = corpus.tool_cards() |
| cards = corpus.skill_cards() |
| roster = sorted(cards) |
| engine = Engine(args.engine) |
| try: |
| for ex in examples: |
| loadable = [t for t in ex["offered"]["loadable"] if t in tool_cards] |
| for request in ex["labels"].get("requests") or []: |
| exact = set(request.get("exact") or []) |
| rest = [t for t in loadable if t not in exact] |
| wanted = set(request.get("after") or []) | {t for t, v in (request.get("scores") or {}).items() if v >= 3} |
| if not rest or not wanted & set(rest): |
| continue |
| scores = engine.call({"method": "rank", "head": "unit-rank", "task": request["need"], "candidates": [tool_cards[t] for t in rest]})["scores"] |
| request_pairs.append([(scores[i], rest[i] in wanted) for i in range(len(rest))]) |
| if ex["partial"]: |
| continue |
| qs = corpus.row_questions(ex) |
| answers = engine.call({"method": "decide", "head": "turn-load", "state": ex["state"], "questions": qs})["answers"] |
| truth = rowfile.truth_tools(ex) |
| for name in qs.get("tools", {}).get("options", {}): |
| p, _ = option_answer(answers, "tools", name) |
| tool_pairs.append((0.0 if p is None else p, name in truth, ex["host"])) |
| guides = ex["labels"]["guides"] |
| for uid in qs.get("guides", {}).get("options", {}): |
| needed = guides.get(uid) |
| if needed is None: |
| continue |
| p, conf = option_answer(answers, "guides", uid) |
| guide_pairs.append((0.0 if p is None else p, 0.0 if conf is None else conf, bool(needed))) |
| judged = ex["labels"].get("skill_scores") or {} |
| if roster and judged: |
| scores = engine.call({"method": "rank", "head": "unit-rank", "task": ex["state"]["user"], "candidates": [cards[name] for name in roster]})["scores"] |
| best = max(range(len(scores)), key=lambda i: scores[i]) |
| skill_tops.append((scores[best], judged.get(roster[best], 0) >= 3)) |
| finally: |
| engine.close() |
|
|
| def best_load_at(pairs): |
| best = (0.0, 0.5) |
| for step in range(5, 96): |
| thr = step / 100 |
| tp = sum(1 for p, y, _ in pairs if p >= thr and y) |
| fp = sum(1 for p, y, _ in pairs if p >= thr and not y) |
| fn = sum(1 for p, y, _ in pairs if p < thr and y) |
| score = fbeta(tp, fp, fn, args.beta) |
| if score > best[0]: |
| best = (score, thr) |
| return best |
|
|
| best = best_load_at(tool_pairs) |
| print("turn:\n tools:\n load_at: %.2f # F%.0f=%.3f support=%d ece=%.3f" % ( |
| best[1], args.beta, best[0], sum(1 for _, y, _ in tool_pairs if y), ece([(p, 1 if y else 0) for p, y, _ in tool_pairs]))) |
| for host in sorted({h for _, _, h in tool_pairs}): |
| pairs = [pair for pair in tool_pairs if pair[2] == host] |
| score, thr = best_load_at(pairs) |
| print(" # %s alone: load_at %.2f, F%.0f=%.3f, support=%d" % (host, thr, args.beta, score, sum(1 for _, y, _ in pairs if y))) |
|
|
| chosen = None |
| for omit in range(5, 51): |
| for floor in range(50, 100, 5): |
| o, f = omit / 100, floor / 100 |
| omitted = [(needed) for p, c, needed in guide_pairs if p < o and c >= f] |
| if not omitted: |
| continue |
| precision = sum(1 for needed in omitted if not needed) / len(omitted) |
| if precision >= args.omission_precision and (chosen is None or len(omitted) > chosen[0]): |
| chosen = (len(omitted), o, f, precision) |
| if chosen is None: |
| print(" guides:\n # no threshold pair reaches omission precision %.2f on %d judged units; keep every unit until the head improves" % (args.omission_precision, len(guide_pairs))) |
| else: |
| print(" guides:\n omit_below: %.2f\n confidence_floor: %.2f # omits %d of %d judged units at precision %.3f" % ( |
| chosen[1], chosen[2], chosen[0], len(guide_pairs), chosen[3])) |
| counts = collections.Counter(needed for _, _, needed in guide_pairs) |
| print("# judged units: needed=%d unneeded=%d" % (counts[True], counts[False])) |
|
|
| max_loads = int(corpus.data.get("request", {}).get("max_loads", 12)) |
| best = None |
| for step in range(50, 401, 5): |
| thr = step / 100 |
| tp = fp = fn = 0 |
| for pairs in request_pairs: |
| top = sorted(pairs, key=lambda x: -x[0])[:max_loads] |
| loaded = [(s, y) for s, y in top if s >= thr] |
| tp += sum(1 for _, y in loaded if y) |
| fp += sum(1 for _, y in loaded if not y) |
| fn += sum(1 for _, y in pairs if y) - sum(1 for _, y in loaded if y) |
| score = fbeta(tp, fp, fn, args.beta) |
| if best is None or score > best[0]: |
| best = (score, thr, tp, fp, fn) |
| if not request_pairs: |
| print("request:\n # no request_tools needs in the examples; load_at unchanged") |
| else: |
| print("request:\n load_at: %.2f # F%.0f=%.3f over %d needs, %.1f loads per need" % ( |
| best[1], args.beta, best[0], len(request_pairs), (best[2] + best[3]) / len(request_pairs))) |
|
|
| chosen = None |
| for step in range(100, 401): |
| thr = step / 100 |
| preloads = [ok for top, ok in skill_tops if top >= thr] |
| if not preloads: |
| continue |
| precision = sum(preloads) / len(preloads) |
| if precision >= args.preload_precision and (chosen is None or len(preloads) > chosen[0]): |
| chosen = (len(preloads), thr, precision) |
| if not skill_tops: |
| print(" skills:\n # no judged skill_scores in the examples; preload_at unchanged") |
| elif chosen is None: |
| print(" skills:\n # no top score reaches preload precision %.2f over %d judged turns; keep preload_at above every top score until the head improves" % (args.preload_precision, len(skill_tops))) |
| else: |
| print(" skills:\n preload_at: %.2f # preloads %d of %d judged turns at precision %.3f" % (chosen[1], chosen[0], len(skill_tops), chosen[2])) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
