MTEB-lite: eng (K=100) and eng-super (K=20) - ids + loader, validation, selection criteria, reference models
3037e25 verified | #!/usr/bin/env python | |
| """MTEB-lite (eng): score a model on the selected items only and estimate its MTEB(eng, v2) scores. | |
| Uses data/mteb_lite/MTEB_lite_eng.json (from mteb_lite_select.py): for every task the selected item ids | |
| and the linear calibration (full ~ a + b * subset score). The model is loaded and prompted exactly as in | |
| mteb_lite_score.py / run_mteb_english.py. Retrieval queries are ranked over their own candidate lists + | |
| the shared random docs (as in the pool scoring), so subset scores are the ones the selection used. | |
| python scripts/mteb_lite_eval.py --model hf:Qwen/Qwen3-Embedding-0.6B --name qwen3-0.6b | |
| python scripts/mteb_lite_eval.py --model native:<export dir> --name NAME | |
| python scripts/mteb_lite_eval.py --manifest data/mteb_lite_v2/MTEB_lite_eng.json --model ... --name NAME (v2) | |
| python scripts/mteb_lite_eval.py --suite ara --manifest data/mteb_lite_ar_v2/MTEB_lite_ara.json --model ... --name NAME | |
| Prints per-task subset / estimated scores and the estimated macro (mean over the 8 task types) and mean; | |
| writes outputs/mteb_lite/eval/<NAME>.json. | |
| """ | |
| from __future__ import annotations | |
| import os as _os | |
| if _os.environ.get("ADIP_HF_ONLINE") != "1": | |
| _os.environ.setdefault("HF_HUB_OFFLINE", "1") | |
| _os.environ.setdefault("HF_DATASETS_OFFLINE", "1") | |
| _os.environ.setdefault("TRANSFORMERS_OFFLINE", "1") | |
| import argparse | |
| import json | |
| import sys | |
| import time | |
| from collections import defaultdict | |
| from pathlib import Path | |
| import numpy as np | |
| HERE = Path(__file__).resolve().parent | |
| sys.path.insert(0, str(HERE)) | |
| sys.path.insert(0, str(HERE.parent / "src")) | |
| import mteb_lite_lib as L # noqa: E402 | |
| from mteb_lite_score import load_model # noqa: E402 | |
| def v2_estimate(doc: dict, ts: L.TaskScores) -> tuple[float, float]: | |
| """(subset statistic, estimated full score) for a v2 selection doc (mean / p-IRT / gp / set metric).""" | |
| a, b = doc["calibration"]["a"], doc["calibration"]["b"] | |
| if doc["estimator"] == "set_metric": | |
| s = float(ts.subset(np.arange(ts.N), exact=True)[0]) | |
| return s, a + b * s | |
| from mteb_lite_select_v2 import map_theta, predict_items | |
| pos = {i: j for j, i in enumerate(ts.ids)} | |
| y = np.array([ts.Y[0, pos[i]] for i in doc["ids"]]) | |
| y = np.where(np.isnan(y), np.nanmean(y) if np.isfinite(np.nanmean(y)) else 0.0, y) | |
| w = np.array(doc["weights"]) | |
| est_mean = float((w * y).sum()) | |
| pp = doc["item_model"] | |
| model = {k: (np.array(v) if isinstance(v, list) else v) for k, v in pp.items()} | |
| ppos = {i: j for j, i in enumerate(doc["pool_ids"])} | |
| sel = np.array([ppos[i] for i in doc["ids"]]) | |
| u = np.array(doc["pool_weights"]) | |
| th = map_theta(model, y, sel) | |
| pred = predict_items(model, th) | |
| rest = np.ones(len(u), bool) | |
| rest[sel] = False | |
| est_pirt = float((u[sel] * y).sum() + (u[rest] * pred[rest]).sum()) | |
| s = {"mean": est_mean, "pirt": est_pirt, "gp": 0.5 * (est_mean + est_pirt)}[doc["estimator"]] | |
| return s, a + b * s | |
| def main() -> None: | |
| L.configure(L.suite_from_argv()) | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--suite", choices=["eng", "ara"], default="eng") | |
| ap.add_argument("--model", required=True) | |
| ap.add_argument("--name", required=True) | |
| ap.add_argument("--manifest", default=str(L.LITE / L.SUITES[L.SUITE]["manifest"]), | |
| help="v1 (data/mteb_lite*/) or v2 (data/mteb_lite*_v2/) manifest") | |
| ap.add_argument("--tasks", default=None) | |
| ap.add_argument("--batch-size", type=int, default=64) | |
| ap.add_argument("--max-length", type=int, default=L.SUITES[L.SUITE]["max_length"]) | |
| ap.add_argument("--out", default=str(L.OUT / "eval")) | |
| args = ap.parse_args() | |
| man = json.loads(Path(args.manifest).read_text()) | |
| tasks = args.tasks.split(",") if args.tasks else list(man["tasks"]) | |
| model = load_model(args.model, args.max_length) | |
| rows, t_all = {}, time.time() | |
| for t in tasks: | |
| spec = man["tasks"][t] | |
| doc = (json.loads((Path(args.manifest).parent / spec["selection"]).read_text()) if "selection" in spec | |
| else spec) | |
| t0 = time.time() | |
| pool = L.restrict_pool(L.load_pool(t), doc["ids"]) | |
| res, emb = L.score_pool(pool, model, batch_size=args.batch_size) | |
| ts = L.TaskScores(t, [res], [emb], pool) | |
| if "estimator" in doc: | |
| s, est = v2_estimate(doc, ts) | |
| else: | |
| s = float(ts.subset(np.arange(ts.N), exact=True)[0]) | |
| est = doc["calibration"]["a"] + doc["calibration"]["b"] * s | |
| rows[t] = {"type": spec["type"], "subset_score": s, "estimated_full": est, "n_items": ts.N, | |
| "seconds": time.time() - t0} | |
| print(f"[lite-eval] {args.name} {t:42s} subset {s:.4f} -> est. {est:.4f} ({time.time() - t0:.0f}s)", | |
| flush=True) | |
| by = defaultdict(list) | |
| for r in rows.values(): | |
| by[r["type"]].append(100 * r["estimated_full"]) | |
| res = {"model": args.model, "name": args.name, "manifest": args.manifest, "n_tasks": len(rows), | |
| "rows": rows, "by_type": {k: float(np.mean(v)) for k, v in by.items()}, | |
| "seconds": time.time() - t_all} | |
| if len(rows) == len(man["tasks"]): | |
| res["estimated_macro"] = float(np.mean(list(res["by_type"].values()))) | |
| res["estimated_mean"] = float(np.mean([100 * r["estimated_full"] for r in rows.values()])) | |
| out = Path(args.out) | |
| out.mkdir(parents=True, exist_ok=True) | |
| (out / f"{args.name}.json").write_text(json.dumps(res, indent=1)) | |
| for k, v in sorted(res["by_type"].items()): | |
| print(f"[lite-eval] {args.name} {k:20s} {v:6.2f}") | |
| print(f"[lite-eval] {args.name}: estimated {'MTEB(eng, v2)' if args.suite == 'eng' else 'Arabic MMTEB (42)'} macro {res.get('estimated_macro')} " | |
| f"mean {res.get('estimated_mean')} ({len(rows)} tasks, {res['seconds']:.0f}s)", flush=True) | |
| if __name__ == "__main__": | |
| main() | |