Datasets:

ML-Intern-lab
/

typed-decisions-benchmark

Tags:

Add benchmark script used for the typed-decisions evaluation

3472f0c verified 26 days ago

10.9 kB

"""Benchmark typed-decision models on LocalLLaMA/typed-decisions (all/test).
Models: mrm8488/embeddinggemma-2-ft-typed-decision, ai-forever/FRIDA-Decisions,
convaiinnovations/laya-typed-decisions.
Metrics per model: accuracy (argmax vs gold label, overall + per question type),
Brier score vs gold distributions, speed (per-case latency, decisions/sec).
Usage: python benchmark.py --limit 2 --device cpu --no-upload   (debug)
       python benchmark.py --device cuda                        (full run)
"""
import argparse
import builtins
import gc
import inspect
import json
import os
import statistics
import time

# Auto-accept any interactive trust_remote_code prompt in non-tty job environments.
builtins.input = lambda *a, **k: "y"
os.environ.setdefault("USE_TF", "0")
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")

import datasets
import torch
import trackio

DATASET = "LocalLLaMA/typed-decisions"
CONFIG = "all"
SPLIT = "test"
RESULTS_REPO = "ML-Intern-lab/typed-decisions-benchmark"
TRACKIO_SPACE = "ML-Intern-lab/typed-decisions-benchmark-trackio"

# noul semantics (verified against probe runs + FRIDA/laya docs): the returned
# scalar is P(true); label = 'true' if p > 0.5 else 'false'.


def flatten_state(state, indent=0):
    lines = []
    for k, v in state.items():
        if isinstance(v, dict):
            lines.append(" " * indent + f"{k}:")
            lines.append(flatten_state(v, indent + 2))
        elif isinstance(v, list):
            lines.append(" " * indent + f"{k}: " + "; ".join(str(x) for x in v))
        else:
            lines.append(" " * indent + f"{k}: {v}")
    return "\n".join(lines)


def load_rows(limit):
    ds = datasets.load_dataset(DATASET, CONFIG, split=SPLIT)
    rows = [dict(r) for r in ds]
    for r in rows:
        r["state"] = json.loads(r["state"])
        r["questions"] = json.loads(r["questions"])
        r["gold"] = json.loads(r["gold"])
    if limit:
        rows = rows[:limit]
    print(f"loaded {len(rows)} rows from {DATASET}/{CONFIG}:{SPLIT}", flush=True)
    return rows


# ------------------------------------------------------------------ models
class EmbeddingGemmaRunner:
    name = "mrm8488/embeddinggemma-2-ft-typed-decision"
    short = "embeddinggemma-2-ft-typed-decision"

    def load(self, device):
        from transformers import AutoModel
        self.model = AutoModel.from_pretrained(
            self.name, trust_remote_code=True
        ).eval().to(device)

    def predict(self, row):
        answers = self.model.decide(
            row["state"], row["questions"], workflow=row["workflow"]
        )
        out = {}
        for qid, a in answers.items():
            out[qid] = {
                "label": str(a.label),
                "probabilities": {str(k): float(v) for k, v in a.probabilities.items()},
            }
        return out


class FridaRunner:
    name = "ai-forever/FRIDA-Decisions"
    short = "frida-decisions"

    def load(self, device):
        from frida_decisions import Judge
        self.judge = Judge.from_pretrained(self.name, device=device)

    def predict(self, row):
        resp = self.judge.judge(
            {"state": flatten_state(row["state"]), "questions": row["questions"]}
        )
        out = {}
        for qid, a in resp["answers"].items():
            qtype = a["type"]
            if qtype == "choice":
                label, probs = str(a["choice"]), a["probabilities"]
            elif qtype == "noul":
                p = float(a["noul"])
                label = "true" if p > 0.5 else "false"
                probs = {"true": p, "false": 1.0 - p}
            elif qtype == "score":
                probs = a["probabilities"]
                label = max(probs, key=probs.get)
            else:
                raise ValueError(f"unexpected FRIDA answer type {qtype} for {qid}")
            out[qid] = {
                "label": str(label),
                "probabilities": {str(k): float(v) for k, v in probs.items()},
            }
        return out


class LayaRunner:
    name = "convaiinnovations/laya-typed-decisions"
    short = "laya-typed-decisions"

    def load(self, device):
        import laya
        kwargs = {}
        if "device" in inspect.signature(laya.load).parameters:
            kwargs["device"] = device
        self.agent = laya.load(self.name, **kwargs)

    def predict(self, row):
        out_raw = self.agent.predict(row["state"], row["questions"])
        out = {}
        for qid, a in out_raw["answers"].items():
            qtype = a["type"]
            if qtype == "choice":
                label, probs = str(a["choice"]), a["probabilities"]
            elif qtype == "noul":
                p = float(a["noul"])
                label = "true" if p > 0.5 else "false"
                probs = {"true": p, "false": 1.0 - p}
            elif qtype == "score":
                probs = a["probabilities"]
                label = max(probs, key=probs.get)
            else:
                raise ValueError(f"unexpected laya answer type {qtype} for {qid}")
            out[qid] = {
                "label": str(label),
                "probabilities": {str(k): float(v) for k, v in probs.items()},
            }
        return out


RUNNERS = [EmbeddingGemmaRunner, FridaRunner, LayaRunner]

# ----------------------------------------------------------------- metrics
def evaluate(runner, rows, device):
    print(f"=== loading {runner.short} ===", flush=True)
    t0 = time.perf_counter()
    runner.load(device)
    load_s = time.perf_counter() - t0
    print(f"loaded in {load_s:.1f}s", flush=True)

    # warm-up on row 0 (excluded from timing, kept in accuracy)
    runner.predict(rows[0])

    per_q = []          # one entry per (case, question)
    latencies = []
    t_start = time.perf_counter()
    for i, row in enumerate(rows):
        t1 = time.perf_counter()
        preds = runner.predict(row)
        latencies.append(time.perf_counter() - t1)
        for qid, qdef in row["questions"].items():
            gold = row["gold"][qid]
            pred = preds[qid]
            gold_label = str(gold["label"])
            gold_probs = {str(k): float(v) for k, v in gold["probabilities"].items()}
            keys = set(gold_probs) | set(pred["probabilities"])
            brier = sum(
                (pred["probabilities"].get(k, 0.0) - gold_probs.get(k, 0.0)) ** 2
                for k in keys
            )
            per_q.append({
                "case_id": row["id"],
                "workflow": row["workflow"],
                "qid": qid,
                "qtype": qdef["type"],
                "gold_label": gold_label,
                "pred_label": pred["label"],
                "correct": pred["label"] == gold_label,
                "brier": brier,
                "pred_probabilities": pred["probabilities"],
            })
        if (i + 1) % 50 == 0 or i + 1 == len(rows):
            acc = sum(q["correct"] for q in per_q) / len(per_q)
            print(f"  row {i+1}/{len(rows)} running accuracy {acc:.3f}", flush=True)
    eval_s = time.perf_counter() - t_start

    metrics = {
        "model": runner.name,
        "short": runner.short,
        "n_cases": len(rows),
        "n_decisions": len(per_q),
        "accuracy": sum(q["correct"] for q in per_q) / len(per_q),
        "brier": sum(q["brier"] for q in per_q) / len(per_q),
        "load_seconds": load_s,
        "eval_seconds": eval_s,
        "latency_mean_ms": statistics.mean(latencies) * 1000,
        "latency_median_ms": statistics.median(latencies) * 1000,
        "latency_p95_ms": sorted(latencies)[int(0.95 * len(latencies))] * 1000,
        "decisions_per_sec": len(per_q) / eval_s,
    }
    by_type = {}
    for t in ("choice", "score", "noul"):
        qs = [q for q in per_q if q["qtype"] == t]
        by_type[t] = {
            "n": len(qs),
            "accuracy": sum(q["correct"] for q in qs) / len(qs),
            "brier": sum(q["brier"] for q in qs) / len(qs),
        }
    metrics["by_type"] = by_type

    del runner
    gc.collect()
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
    return metrics, per_q


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--limit", type=int, default=0, help="first N cases only (0 = all 400)")
    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    ap.add_argument("--models", nargs="*", default=None, help="subset: embeddinggemma frida laya")
    ap.add_argument("--no-upload", action="store_true")
    ap.add_argument("--tag", default="run", help="subfolder tag for results files")
    args = ap.parse_args()

    rows = load_rows(args.limit)
    all_runners = {r.short.split("-")[0]: r for r in RUNNERS}
    alias = {"embeddinggemma": EmbeddingGemmaRunner, "frida": FridaRunner,
             "laya": LayaRunner, "all": None}
    chosen = RUNNERS
    if args.models:
        chosen = [alias[m] for m in args.models]

    if not args.no_upload:
        trackio.init(project="typed-decisions-benchmark", space_id=TRACKIO_SPACE)
    summary = {"dataset": f"{DATASET}/{CONFIG}:{SPLIT}", "device": args.device,
               "n_cases": len(rows), "models": []}
    for k, runner_cls in enumerate(chosen):
        metrics, per_q = evaluate(runner_cls(), rows, args.device)
        summary["models"].append(metrics)
        print("METRICS " + json.dumps(metrics), flush=True)
        if not args.no_upload:
            trackio.log({
                f"{metrics['short']}/accuracy": metrics["accuracy"],
                f"{metrics['short']}/brier": metrics["brier"],
                f"{metrics['short']}/latency_mean_ms": metrics["latency_mean_ms"],
                f"{metrics['short']}/decisions_per_sec": metrics["decisions_per_sec"],
            }, step=k + 1)
        if not args.no_upload:
            from huggingface_hub import HfApi
            api = HfApi()
            base = f"results/{args.tag}/{metrics['short']}"
            api.upload_file(
                path_or_fileobj=json.dumps(metrics, indent=2).encode(),
                path_in_repo=f"{base}/metrics.json",
                repo_id=RESULTS_REPO, repo_type="dataset",
            )
            api.upload_file(
                path_or_fileobj="\n".join(json.dumps(q) for q in per_q).encode(),
                path_in_repo=f"{base}/predictions.jsonl",
                repo_id=RESULTS_REPO, repo_type="dataset",
            )

    if not args.no_upload:
        from huggingface_hub import HfApi
        HfApi().upload_file(
            path_or_fileobj=json.dumps(summary, indent=2).encode(),
            path_in_repo=f"results/{args.tag}/summary.json",
            repo_id=RESULTS_REPO, repo_type="dataset",
        )

    if not args.no_upload:
        trackio.finish()
    print("ALL DONE\n" + json.dumps(summary, indent=2), flush=True)


if __name__ == "__main__":
    main()

	"""Benchmark typed-decision models on LocalLLaMA/typed-decisions (all/test).

	Models: mrm8488/embeddinggemma-2-ft-typed-decision, ai-forever/FRIDA-Decisions,
	convaiinnovations/laya-typed-decisions.

	Metrics per model: accuracy (argmax vs gold label, overall + per question type),
	Brier score vs gold distributions, speed (per-case latency, decisions/sec).

	Usage: python benchmark.py --limit 2 --device cpu --no-upload (debug)
	python benchmark.py --device cuda (full run)
	"""
	import argparse
	import builtins
	import gc
	import inspect
	import json
	import os
	import statistics
	import time

	# Auto-accept any interactive trust_remote_code prompt in non-tty job environments.
	builtins.input = lambda a, *k: "y"
	os.environ.setdefault("USE_TF", "0")
	os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
	os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")

	import datasets
	import torch
	import trackio

	DATASET = "LocalLLaMA/typed-decisions"
	CONFIG = "all"
	SPLIT = "test"
	RESULTS_REPO = "ML-Intern-lab/typed-decisions-benchmark"
	TRACKIO_SPACE = "ML-Intern-lab/typed-decisions-benchmark-trackio"

	# noul semantics (verified against probe runs + FRIDA/laya docs): the returned
	# scalar is P(true); label = 'true' if p > 0.5 else 'false'.


	def flatten_state(state, indent=0):
	lines = []
	for k, v in state.items():
	if isinstance(v, dict):
	lines.append(" " * indent + f"{k}:")
	lines.append(flatten_state(v, indent + 2))
	elif isinstance(v, list):
	lines.append(" " * indent + f"{k}: " + "; ".join(str(x) for x in v))
	else:
	lines.append(" " * indent + f"{k}: {v}")
	return "\n".join(lines)


	def load_rows(limit):
	ds = datasets.load_dataset(DATASET, CONFIG, split=SPLIT)
	rows = [dict(r) for r in ds]
	for r in rows:
	r["state"] = json.loads(r["state"])
	r["questions"] = json.loads(r["questions"])
	r["gold"] = json.loads(r["gold"])
	if limit:
	rows = rows[:limit]
	print(f"loaded {len(rows)} rows from {DATASET}/{CONFIG}:{SPLIT}", flush=True)
	return rows


	# ------------------------------------------------------------------ models
	class EmbeddingGemmaRunner:
	name = "mrm8488/embeddinggemma-2-ft-typed-decision"
	short = "embeddinggemma-2-ft-typed-decision"

	def load(self, device):
	from transformers import AutoModel
	self.model = AutoModel.from_pretrained(
	self.name, trust_remote_code=True
	).eval().to(device)

	def predict(self, row):
	answers = self.model.decide(
	row["state"], row["questions"], workflow=row["workflow"]
	)
	out = {}
	for qid, a in answers.items():
	out[qid] = {
	"label": str(a.label),
	"probabilities": {str(k): float(v) for k, v in a.probabilities.items()},
	}
	return out


	class FridaRunner:
	name = "ai-forever/FRIDA-Decisions"
	short = "frida-decisions"

	def load(self, device):
	from frida_decisions import Judge
	self.judge = Judge.from_pretrained(self.name, device=device)

	def predict(self, row):
	resp = self.judge.judge(
	{"state": flatten_state(row["state"]), "questions": row["questions"]}
	)
	out = {}
	for qid, a in resp["answers"].items():
	qtype = a["type"]
	if qtype == "choice":
	label, probs = str(a["choice"]), a["probabilities"]
	elif qtype == "noul":
	p = float(a["noul"])
	label = "true" if p > 0.5 else "false"
	probs = {"true": p, "false": 1.0 - p}
	elif qtype == "score":
	probs = a["probabilities"]
	label = max(probs, key=probs.get)
	else:
	raise ValueError(f"unexpected FRIDA answer type {qtype} for {qid}")
	out[qid] = {
	"label": str(label),
	"probabilities": {str(k): float(v) for k, v in probs.items()},
	}
	return out


	class LayaRunner:
	name = "convaiinnovations/laya-typed-decisions"
	short = "laya-typed-decisions"

	def load(self, device):
	import laya
	kwargs = {}
	if "device" in inspect.signature(laya.load).parameters:
	kwargs["device"] = device
	self.agent = laya.load(self.name, **kwargs)

	def predict(self, row):
	out_raw = self.agent.predict(row["state"], row["questions"])
	out = {}
	for qid, a in out_raw["answers"].items():
	qtype = a["type"]
	if qtype == "choice":
	label, probs = str(a["choice"]), a["probabilities"]
	elif qtype == "noul":
	p = float(a["noul"])
	label = "true" if p > 0.5 else "false"
	probs = {"true": p, "false": 1.0 - p}
	elif qtype == "score":
	probs = a["probabilities"]
	label = max(probs, key=probs.get)
	else:
	raise ValueError(f"unexpected laya answer type {qtype} for {qid}")
	out[qid] = {
	"label": str(label),
	"probabilities": {str(k): float(v) for k, v in probs.items()},
	}
	return out


	RUNNERS = [EmbeddingGemmaRunner, FridaRunner, LayaRunner]

	# ----------------------------------------------------------------- metrics
	def evaluate(runner, rows, device):
	print(f"=== loading {runner.short} ===", flush=True)
	t0 = time.perf_counter()
	runner.load(device)
	load_s = time.perf_counter() - t0
	print(f"loaded in {load_s:.1f}s", flush=True)

	# warm-up on row 0 (excluded from timing, kept in accuracy)
	runner.predict(rows[0])

	per_q = [] # one entry per (case, question)
	latencies = []
	t_start = time.perf_counter()
	for i, row in enumerate(rows):
	t1 = time.perf_counter()
	preds = runner.predict(row)
	latencies.append(time.perf_counter() - t1)
	for qid, qdef in row["questions"].items():
	gold = row["gold"][qid]
	pred = preds[qid]
	gold_label = str(gold["label"])
	gold_probs = {str(k): float(v) for k, v in gold["probabilities"].items()}
	keys = set(gold_probs) \| set(pred["probabilities"])
	brier = sum(
	(pred["probabilities"].get(k, 0.0) - gold_probs.get(k, 0.0)) ** 2
	for k in keys
	)
	per_q.append({
	"case_id": row["id"],
	"workflow": row["workflow"],
	"qid": qid,
	"qtype": qdef["type"],
	"gold_label": gold_label,
	"pred_label": pred["label"],
	"correct": pred["label"] == gold_label,
	"brier": brier,
	"pred_probabilities": pred["probabilities"],
	})
	if (i + 1) % 50 == 0 or i + 1 == len(rows):
	acc = sum(q["correct"] for q in per_q) / len(per_q)
	print(f" row {i+1}/{len(rows)} running accuracy {acc:.3f}", flush=True)
	eval_s = time.perf_counter() - t_start

	metrics = {
	"model": runner.name,
	"short": runner.short,
	"n_cases": len(rows),
	"n_decisions": len(per_q),
	"accuracy": sum(q["correct"] for q in per_q) / len(per_q),
	"brier": sum(q["brier"] for q in per_q) / len(per_q),
	"load_seconds": load_s,
	"eval_seconds": eval_s,
	"latency_mean_ms": statistics.mean(latencies) * 1000,
	"latency_median_ms": statistics.median(latencies) * 1000,
	"latency_p95_ms": sorted(latencies)[int(0.95 * len(latencies))] * 1000,
	"decisions_per_sec": len(per_q) / eval_s,
	}
	by_type = {}
	for t in ("choice", "score", "noul"):
	qs = [q for q in per_q if q["qtype"] == t]
	by_type[t] = {
	"n": len(qs),
	"accuracy": sum(q["correct"] for q in qs) / len(qs),
	"brier": sum(q["brier"] for q in qs) / len(qs),
	}
	metrics["by_type"] = by_type

	del runner
	gc.collect()
	if torch.cuda.is_available():
	torch.cuda.empty_cache()
	return metrics, per_q


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("--limit", type=int, default=0, help="first N cases only (0 = all 400)")
	ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
	ap.add_argument("--models", nargs="*", default=None, help="subset: embeddinggemma frida laya")
	ap.add_argument("--no-upload", action="store_true")
	ap.add_argument("--tag", default="run", help="subfolder tag for results files")
	args = ap.parse_args()

	rows = load_rows(args.limit)
	all_runners = {r.short.split("-")[0]: r for r in RUNNERS}
	alias = {"embeddinggemma": EmbeddingGemmaRunner, "frida": FridaRunner,
	"laya": LayaRunner, "all": None}
	chosen = RUNNERS
	if args.models:
	chosen = [alias[m] for m in args.models]

	if not args.no_upload:
	trackio.init(project="typed-decisions-benchmark", space_id=TRACKIO_SPACE)
	summary = {"dataset": f"{DATASET}/{CONFIG}:{SPLIT}", "device": args.device,
	"n_cases": len(rows), "models": []}
	for k, runner_cls in enumerate(chosen):
	metrics, per_q = evaluate(runner_cls(), rows, args.device)
	summary["models"].append(metrics)
	print("METRICS " + json.dumps(metrics), flush=True)
	if not args.no_upload:
	trackio.log({
	f"{metrics['short']}/accuracy": metrics["accuracy"],
	f"{metrics['short']}/brier": metrics["brier"],
	f"{metrics['short']}/latency_mean_ms": metrics["latency_mean_ms"],
	f"{metrics['short']}/decisions_per_sec": metrics["decisions_per_sec"],
	}, step=k + 1)
	if not args.no_upload:
	from huggingface_hub import HfApi
	api = HfApi()
	base = f"results/{args.tag}/{metrics['short']}"
	api.upload_file(
	path_or_fileobj=json.dumps(metrics, indent=2).encode(),
	path_in_repo=f"{base}/metrics.json",
	repo_id=RESULTS_REPO, repo_type="dataset",
	)
	api.upload_file(
	path_or_fileobj="\n".join(json.dumps(q) for q in per_q).encode(),
	path_in_repo=f"{base}/predictions.jsonl",
	repo_id=RESULTS_REPO, repo_type="dataset",
	)

	if not args.no_upload:
	from huggingface_hub import HfApi
	HfApi().upload_file(
	path_or_fileobj=json.dumps(summary, indent=2).encode(),
	path_in_repo=f"results/{args.tag}/summary.json",
	repo_id=RESULTS_REPO, repo_type="dataset",
	)

	if not args.no_upload:
	trackio.finish()
	print("ALL DONE\n" + json.dumps(summary, indent=2), flush=True)


	if __name__ == "__main__":
	main()