#!/usr/bin/env python """Build the public, ID-only MTEB-lite release folder (Hugging Face dataset repo ADIP-QCRI/MTEB-lite). python scripts/mteb_lite_release.py build [--out outputs/hf_upload/MTEB-lite] specs, manifests, docs, code python scripts/mteb_lite_release.py roundtrip [--jobs 16] reconstruct every task with mteb_lite.py from the original datasets and compare with our local pools (texts must match) python scripts/mteb_lite_release.py stats texts / tokens / est. encode minutes per config (Qwen3 tokenizer) Configs: eng (data/mteb_lite_v2, K=100), eng-super (data/mteb_lite_super_v2, K=20); ara / ara-super slot in the same way (CONFIGS) once the Arabic selection exists. No text from any dataset is written: only ids, row indices, qrels / label weights needed for scoring, selection weights and calibration coefficients. """ from __future__ import annotations import argparse import csv import json import shutil import sys from collections import defaultdict from pathlib import Path HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) import mteb_lite_lib as L # noqa: E402 REPO = L.REPO OUT = REPO / "outputs" / "hf_upload" / "MTEB-lite" ALL_CONFIGS = { # config -> (suite, selection dir, validation report stem, selection version) "eng@v2": ("eng", REPO / "data" / "mteb_lite_v2", REPO / "outputs" / "mteb_lite" / "selection_report_v2", "v2"), "eng-super@v2": ("eng", REPO / "data" / "mteb_lite_super_v2", REPO / "outputs" / "mteb_lite" / "selection_report_v2_super", "v2"), "eng@v3": ("eng", REPO / "data" / "mteb_lite_v3", REPO / "outputs" / "mteb_lite" / "selection_report_v3", "v3"), "eng-super@v3": ("eng", REPO / "data" / "mteb_lite_super_v3", REPO / "outputs" / "mteb_lite" / "selection_report_v3_super", "v3"), "ara@v3": ("ara", REPO / "data" / "mteb_lite_ar", REPO / "outputs" / "mteb_lite_ar" / "selection_report", "v3"), "ara-super@v3": ("ara", REPO / "data" / "mteb_lite_ar_super", REPO / "outputs" / "mteb_lite_ar" / "selection_report_super", "v3"), "ara@v4": ("ara", REPO / "data" / "mteb_lite_ar_v4", REPO / "outputs" / "mteb_lite_ar" / "selection_report_v4", "v4"), "ara-super@v4": ("ara", REPO / "data" / "mteb_lite_ar_super_v4", REPO / "outputs" / "mteb_lite_ar" / "selection_report_v4_super", "v4"), } CONFIGS: dict = {} # config -> (suite, selection dir, report stem, version); set by set_configs() def set_configs(names: list[str], versions: dict) -> None: """versions: {config: selection version} (default v3 for ara*, v2 for eng*).""" CONFIGS.clear() for n in names: v = versions.get(n, "v3" if n.startswith("ara") else "v2") CONFIGS[n] = ALL_CONFIGS[f"{n}@{v}"] BENCH = {"eng": "MTEB(eng, v2)", "ara": "Arabic MMTEB (42 test tasks)"} TOK_PER_S = 30000 # measured: Qwen3-Embedding-0.6B in our MTEB runs, 25-33k tokens/s on one GPU CODE = ["mteb_lite_lib.py", "mteb_lite_pool.py", "mteb_lite_score.py", "mteb_lite_score_merges.py", "mteb_lite_select.py", "mteb_lite_select_v2.py", "mteb_lite_eval.py", "mteb_lite_public_full.py", "mteb_lite_score_list.sh", "mteb_lite_release.py", "mteb_lite_release_docs.py", "mteb_lite_release_models.py"] def manifest_of(sel_dir: Path, suite: str) -> dict: return json.loads((sel_dir / L.SUITES[suite]["manifest"]).read_text()) def task_release_spec(task: str, doc: dict, pool: dict, suite: str) -> dict: """ID-only description of one task's selected items (+ everything scoring needs).""" t = L.get_task(task) rp = L.restrict_pool(pool, doc["ids"]) ty = pool["type"] spec = {"task": task, "type": ty, "main_score": pool["main_score"], "eval_split": pool["eval_split"], "hf_subsets": pool["hf_subset"] if isinstance(pool["hf_subset"], list) else [pool["hf_subset"]], "dataset": {"path": t.metadata.dataset.get("path"), "revision": t.metadata.dataset.get("revision")}, "K": len(doc["ids"]), "ids": doc["ids"], "estimator": {"mean": "weighted_mean", "pirt": "pirt", "gp": "gp"}.get(doc["estimator"], "set_metric"), "calibration": doc["calibration"], "item_key": L.ITEM_KEY[ty]} if suite == "eng": spec["benchmark"] = L.BENCHMARK else: spec["hf_subsets_filter"] = spec["hf_subsets"] if doc["estimator"] in ("mean", "pirt", "gp"): spec["weights"] = doc["weights"] if doc["estimator"] != "mean": # p-IRT: item ids + item parameters of the whole candidate pool spec["irt"] = {"pool_ids": doc["pool_ids"], "pool_weights": doc["pool_weights"], "item_model": doc["item_model"], "theta_scale": doc.get("theta_scale")} elif doc["estimator"] != "set_metric": raise ValueError(f"{task}: estimator {doc['estimator']} not supported by the release loader") if ty == "Reranking" and "ndcg" in str(pool["main_score"]).lower(): spec["item_key"] = "ndcg10" if ty == "Retrieval": spec["candidates"] = rp["candidates"] spec["qrels"] = rp["qrels"] spec["ignore_identical_ids"] = rp.get("ignore_identical_ids", False) # content hashes: some mteb loaders number queries / docs via enumerate(set(...)) (e.g. MintakaRetrieval), so # their ids change with PYTHONHASHSEED; the loader maps texts by hash and keeps these ids (qrels stay valid) import hashlib h = lambda x: hashlib.sha1(x.encode("utf-8")).hexdigest()[:16] # noqa: E731 spec["text_sha1"] = {"queries": {q: h(v) for q, v in rp["queries"].items()}, "docs": {d: h(v) for d, v in rp["corpus"].items()}} if "random_docs_by_subset" in rp: spec["random_docs_by_subset"] = rp["random_docs_by_subset"] spec["query_subset"] = rp["query_subset"] else: spec["random_docs"] = rp["random_docs"] elif ty == "Classification": if "groups" in pool: groups = {k: {"train_rows": g["train"]["orig_index"], "experiments": g["experiments"]} for k, g in pool["groups"].items()} else: groups = {"": {"train_rows": pool["train"]["orig_index"], "experiments": pool["experiments"]}} spec.update({"groups": groups, "samples_per_label": pool.get("samples_per_label"), "n_experiments": pool.get("n_experiments"), "undersampling_seed": 42, "logreg": {"random_state": 42, "max_iter": 100}}) elif ty == "PairClassification": spec["label_weights"] = pool.get("label_weights") elif ty == "Clustering": spec["n_levels"] = pool["n_levels"] spec["max_depth"] = getattr(t, "max_depth", None) spec["multi_set"] = any("subset" in x for x in pool["items"]) spec["kmeans"] = {"runs": L.KMEANS_RUNS, "random_state": "run index", "n_init": 1, "max_iter": 100} elif ty == "BitextMining": tgt = {x["id"]: x["target"] for x in rp["items"]} spec["targets"] = [tgt[i] for i in doc["ids"]] # aligned with spec["ids"] spec["bitext_candidates"] = rp["bitext_candidates"] spec["parallel"] = pool.get("parallel", False) return spec # ----------------------------------------------------------------------------- build def build(out: Path) -> None: out.mkdir(parents=True, exist_ok=True) for cfg, (suite, sel_dir, rep, ver) in CONFIGS.items(): L.configure(suite) man = manifest_of(sel_dir, suite) d = out / cfg if d.exists(): shutil.rmtree(d) d.mkdir(parents=True) tasks, cal_rows = {}, [] fulls = full_scores_of(suite) for task, m in man["tasks"].items(): doc = json.loads((sel_dir / m["selection"]).read_text()) spec = task_release_spec(task, doc, L.load_pool(task), suite) fit = calib_fit(task, doc, suite, fulls) spec["calibration"] = {**spec["calibration"], **fit} (d / f"{task}.json").write_text(json.dumps(spec)) tasks[task] = {"type": spec["type"], "main_score": spec["main_score"], "K": spec["K"], "estimator": spec["estimator"], "calibration": spec["calibration"], "dataset": spec["dataset"], "eval_split": spec["eval_split"], "hf_subsets": spec["hf_subsets"]} cal_rows.append({"task": task, "task_type": spec["type"], "main_score": spec["main_score"], "estimator": spec["estimator"], "K": spec["K"], "a": spec["calibration"]["a"], "b": spec["calibration"]["b"], "n_fit_models": fit["n_fit"], "fit_pearson_r": fit["fit_r"], "fit_residual_sd": fit["fit_resid_sd"], "fitted_on": f"models.csv rows with role_{cfg} = selection+calibration+LOMO-held-out " "(those with a full score for this task)"}) with open(d / "calibration.csv", "w", newline="") as f: w = csv.DictWriter(f, fieldnames=list(cal_rows[0])) w.writeheader() w.writerows(cal_rows) import mteb manifest = {"name": "MTEB-lite", "config": cfg, "benchmark": BENCH[suite], "source_benchmark": L.BENCHMARK if suite == "eng" else "MMTEB Arabic subsets", "mteb_version": mteb.__version__, "K": man["K"], "K_set": man.get("K_set", man["K"]), "n_tasks": len(tasks), "aggregate": {"macro": "mean over task types of the mean over tasks (x100)", "mean": "mean over tasks (x100)"}, "method": man["method"], "selection_version": ver, "n_reference_models": len(man["reference_models"]), "reference_models": man["reference_models"], "calibration": "full_estimate = a + b * subset_statistic per task (see calibration.csv)", "tasks": tasks} (d / "manifest.json").write_text(json.dumps(manifest, indent=1)) vd = out / "validation" vd.mkdir(exist_ok=True) for ext in (".md", ".json"): # no internal absolute paths in the public copies txt = rep.with_suffix(ext).read_text().replace(str(REPO) + "/", "").replace(str(REPO), ".") (vd / f"{cfg}{ext}").write_text(txt) print(f"[release] {cfg}: {len(tasks)} tasks -> {d}") shutil.copy(HERE / "mteb_lite_hf" / "mteb_lite.py", out / "mteb_lite.py") cd = out / "code" if cd.exists(): shutil.rmtree(cd) cd.mkdir() for f in CODE: shutil.copy(HERE / f, cd / f) write_models_csv(out) write_docs(out) for pc in out.rglob("__pycache__"): shutil.rmtree(pc, ignore_errors=True) # ----------------------------------------------------------------------------- calibration / models.csv _FULLS: dict = {} def full_scores_of(suite: str) -> dict: """{model: {task: full main score}} of every scored model of the suite (as the selection used them).""" if suite not in _FULLS: import mteb_lite_select as S1 import mteb_lite_select_v2 as S2 L.configure(suite) names = sorted(p.name for p in L.SCORES.iterdir() if p.is_dir()) csvp = str(L.LITE / "public_full.csv") _FULLS[suite] = S1.full_scores(names, csvp) if suite == "eng" else S2.ara_full_scores(names, csvp) return _FULLS[suite] def calib_fit(task: str, doc: dict, suite: str, fulls: dict) -> dict: """Goodness of the per-task linear calibration on the reference models it was fitted on.""" import numpy as np import mteb_lite_select_v2 as S2 L.configure(suite) names = [n for n in doc["reference_models"] if task in fulls.get(n, {})] res, embs = [], [] for n in names: r, e = L.load_scores(n, task) res.append(r) embs.append(e) pool = L.load_pool(task) ts = L.TaskScores(task, res, embs, pool) f = np.array([fulls[n][task] for n in names]) cols = np.array([ts.ids.index(i) for i in doc["ids"]]) if doc["estimator"] == "set_metric": est = ts.subset(cols, exact=ts.type == "Clustering") else: Y = np.where(np.isnan(ts.Y), np.nan_to_num(np.nanmean(ts.Y, 0))[None], ts.Y) w = np.array(doc["weights"]) est = (Y[:, cols] * w[None]).sum(1) if doc["estimator"] in ("pirt", "gp"): model = {k: (np.array(v) if isinstance(v, list) else v) for k, v in doc["item_model"].items()} u = np.array(doc["pool_weights"]) ppos = {i: j for j, i in enumerate(doc["pool_ids"])} sel = np.array([ppos[i] for i in doc["ids"]]) rest = np.ones(len(u), bool) rest[sel] = False pir = [] for m in range(len(names)): th = S2.map_theta(model, Y[m, cols], sel) pir.append((u[sel] * Y[m, cols]).sum() + (u[rest] * S2.predict_items(model, th)[rest]).sum()) pir = np.array(pir) est = pir if doc["estimator"] == "pirt" else 0.5 * (est + pir) a, b = doc["calibration"]["a"], doc["calibration"]["b"] pred = a + b * est ok = ~np.isnan(pred) r = float(np.corrcoef(pred[ok], f[ok])[0, 1]) if ok.sum() > 2 and pred[ok].std() > 0 else float("nan") return {"n_fit": int(ok.sum()), "fit_r": r, "fit_resid_sd": float(np.std(f[ok] - pred[ok]))} def write_models_csv(out: Path) -> list[dict]: import mteb_lite_release_models as RM import mteb_lite_select_v2 as S2 roles = {} for cfg, (suite, sel_dir, rep, ver) in CONFIGS.items(): r = json.loads(rep.with_suffix(".json").read_text()) combo = r["choice"].get("combo") agg = set((r["aggregate"]["family"].get(combo) or {}).get("models", [])) roles[cfg] = (suite, set(r["reference"]), agg) suites = [su for su in ("eng", "ara") if L.SUITES[su]["out"].joinpath("scores").exists()] # all scored suites scored = {} for su in suites: L.configure(su) scored[su] = {p.name for p in L.SCORES.iterdir() if p.is_dir()} fulls = {su: full_scores_of(su) for su in suites} names = sorted(set().union(*scored.values())) rows = [] for n in names: d = RM.describe(n) row = {"internal_id": n, "display_name": d["display_name"], "family": d["family"], "type": d["type"], "merge_recipe": d["recipe"], "suites_scored": "/".join(su for su in suites if n in scored[su])} for su in suites: nt = len(fulls[su].get(n, {})) if n in scored[su] else 0 row[f"full_score_source_{su}"] = ("" if not nt else ("official MTEB results" if d["type"] == "public" else "our runs (mteb 1.39.7)")) row[f"tasks_with_full_score_{su}"] = nt for cfg, (su, ref, agg) in roles.items(): if n in ref: role = "selection+calibration+LOMO-held-out" + ("+aggregate-validation" if n in agg else "") elif n in scored[su] and fulls[su].get(n): role = "not used (family cap: <=3 per family)" if S2.family(n) in {S2.family(m) for m in ref} \ else "not used" elif n in scored[su]: role = "not used (no full scores)" else: role = "-" row[f"role_{cfg}"] = role rows.append(row) with open(out / "models.csv", "w", newline="") as f: w = csv.DictWriter(f, fieldnames=list(rows[0])) w.writeheader() w.writerows(rows) print(f"[release] models.csv: {len(rows)} models") return rows # ----------------------------------------------------------------------------- stats / roundtrip def stats() -> dict: from transformers import AutoTokenizer tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-Embedding-0.6B") res = {} for cfg, (suite, sel_dir, _, _v) in CONFIGS.items(): L.configure(suite) man = manifest_of(sel_dir, suite) cap = L.SUITES[suite]["max_length"] or 8192 n_items = n_texts = n_tok = 0 per = {} for task, m in man["tasks"].items(): doc = json.loads((sel_dir / m["selection"]).read_text()) rp = L.restrict_pool(L.load_pool(task), doc["ids"]) texts = list(dict.fromkeys(L.texts_to_encode(rp))) k = 0 for s in range(0, len(texts), 4096): enc = tok([t for t, _ in texts[s:s + 4096]], add_special_tokens=False)["input_ids"] k += sum(min(len(e), cap) + (20 if r != "document" else 1) for e, (_, r) in zip(enc, texts[s:s + 4096])) per[task] = {"items": len(doc["ids"]), "texts": len(texts), "tokens": k} n_items += len(doc["ids"]) n_texts += len(texts) n_tok += k res[cfg] = {"items": n_items, "texts": n_texts, "tokens": n_tok, "minutes_0.6B": n_tok / TOK_PER_S / 60, "per_task": per} print(f"[release] {cfg}: {n_items} items, {n_texts} texts, {n_tok / 1e6:.2f}M tokens, " f"~{n_tok / TOK_PER_S / 60:.1f} min / 0.6B model") (OUT / "stats.json").write_text(json.dumps(res, indent=1)) if OUT.exists() else None return res def canon(p: dict) -> dict: t = p["type"] if t == "Retrieval": return {"queries": p["queries"], "corpus": p["corpus"], "candidates": p["candidates"], "qrels": p["qrels"], "random": p.get("random_docs", p.get("random_docs_by_subset"))} c = {"items": [{k: ([str(v) for v in x[k]] if k == "labels" else (str(x[k]) if k == "label" else x[k])) for k in sorted(x)} for x in sorted(p["items"], key=lambda x: x["id"])]} if t == "Classification": groups = p["groups"] if "groups" in p else {"": {"train": p["train"], "experiments": p["experiments"]}} c["train"] = {k: [list(g["train"]["text"]), [str(v) for v in g["train"]["label"]], g["experiments"]] for k, g in groups.items()} if t == "BitextMining": c["texts"] = {k: p["bitext_texts"][k] for k in sorted(p["bitext_texts"])} c["cands"] = p["bitext_candidates"] return c def roundtrip_one(cfg: str, task: str, out: str) -> dict: sys.path.insert(0, out) import mteb_lite as ML ML.HERE = Path(out) suite, sel_dir, _, _v = CONFIGS[cfg] L.configure(suite) spec = json.loads((Path(out) / cfg / f"{task}.json").read_text()) rp = L.restrict_pool(L.load_pool(task), spec["ids"]) try: got = ML.load_task(cfg, task, spec) except Exception as e: import traceback return {"cfg": cfg, "task": task, "ok": False, "error": f"{type(e).__name__}: {e}", "tb": traceback.format_exc()[-800:]} a, b = canon(rp), canon(got) bad = [] for k in a: if a[k] != b.get(k): if isinstance(a[k], dict): diff = [x for x in a[k] if a[k][x] != b.get(k, {}).get(x)] bad.append(f"{k}: {len(diff)} differ, e.g. {diff[:3]}") elif isinstance(a[k], list): diff = [i for i, (x, y) in enumerate(zip(a[k], b.get(k, []))) if x != y] bad.append(f"{k}: {len(diff)} differ (len {len(a[k])} vs {len(b.get(k, []))}), e.g. {diff[:3]}") else: bad.append(k) n = len(rp["queries"]) if rp["type"] == "Retrieval" else len(rp["items"]) return {"cfg": cfg, "task": task, "ok": not bad, "n": n, "mismatch": bad} def roundtrip(out: Path, jobs: int, cfgs: list[str]) -> None: from concurrent.futures import ProcessPoolExecutor work = [] for cfg in cfgs: man = json.loads((out / cfg / "manifest.json").read_text()) work += [(cfg, t, str(out)) for t in man["tasks"]] res = [] with ProcessPoolExecutor(jobs) as ex: for r in ex.map(roundtrip_one, *zip(*work)): res.append(r) print(f"[roundtrip] {r['cfg']:10s} {r['task']:42s} {'OK' if r['ok'] else 'MISMATCH'} " f"{r.get('n', '')} {r.get('mismatch') or r.get('error') or ''}", flush=True) bad = [r for r in res if not r["ok"]] (out.parent / "MTEB-lite_roundtrip.json").write_text(json.dumps(res, indent=1)) print(f"[roundtrip] {len(res) - len(bad)}/{len(res)} tasks identical; mismatches: {len(bad)}") # ----------------------------------------------------------------------------- docs NOTES: dict = {} def write_docs(out: Path) -> None: from mteb_lite_release_docs import readme, selection_md st = json.loads((out / "stats.json").read_text()) if (out / "stats.json").exists() else {} st = {k: v for k, v in st.items() if k in CONFIGS} reps = {cfg: json.loads(r.with_suffix(".json").read_text()) for cfg, (_, _, r, _v) in CONFIGS.items()} mans = {cfg: json.loads((out / cfg / "manifest.json").read_text()) for cfg in CONFIGS} models = list(csv.DictReader(open(out / "models.csv"))) cal = {} for cfg in CONFIGS: rows = list(csv.DictReader(open(out / cfg / "calibration.csv"))) for r in rows: for k in ("fit_pearson_r", "fit_residual_sd"): r[k] = float(r[k]) cal[cfg] = rows notes = dict(NOTES) if any(c.startswith("ara") for c in CONFIGS): notes.setdefault("ara", ARA_NOTE) (out / "README.md").write_text(readme(st, reps, mans, models, cal, notes)) (out / "SELECTION.md").write_text(selection_md(reps, mans)) ARA_NOTE = """ **Arabic configs.** These are the 42 Arabic MMTEB test tasks (7 bitext mining, 14 classification, 2 clustering, 2 pair classification, 2 reranking, 11 retrieval, 4 STS). Each task is restricted to its Arabic hf_subsets (Arabic, Arabic dialects, and Arabic-English pairs) and to the split our Arabic MMTEB evaluation uses, and the task score is the mean over subsets. Texts are capped at 512 tokens. The MIRACLReranking pool was cut to 300 queries (encode cost). The full-task scores of the 8 multilingual public reference models (multilingual-e5 small / base / large, bge-m3, LaBSE, embeddinggemma-300m, paraphrase-multilingual MiniLM-L12 / mpnet-base) are our own complete runs of all 42 tasks with the same subsets and splits; the English-only public models enter only the tasks with official full scores. Only `ara-super` (K=20) is released: it beats uniform random K under family-level leave-one-model-out (macro tau 0.732 vs 0.711, mean tau 0.772 vs 0.764). The K=100 Arabic selection does not yet beat random K (macro tau 0.769 vs 0.778) and is withheld until it does. """ def main() -> None: global OUT ap = argparse.ArgumentParser() ap.add_argument("cmd", choices=["build", "roundtrip", "stats", "docs"]) ap.add_argument("--out", default=str(OUT)) ap.add_argument("--jobs", type=int, default=8) ap.add_argument("--configs", default="eng,eng-super", help="any of eng,eng-super,ara,ara-super") ap.add_argument("--versions", default="eng=v2,eng-super=v3", help="selection version per config (eng / eng-super: v2 | v3; ara*: v3 | v4)") ap.add_argument("--eng-note", default="", help="README sentence on which English selection version is used and why") args = ap.parse_args() if args.eng_note: NOTES["eng"] = args.eng_note.replace("\\`", "`") set_configs(args.configs.split(","), dict(kv.split("=") for kv in args.versions.split(",") if kv)) OUT = Path(args.out) if args.cmd == "build": build(OUT) elif args.cmd == "stats": stats() write_docs(OUT) elif args.cmd == "docs": write_docs(OUT) else: roundtrip(OUT, args.jobs, list(CONFIGS)) if __name__ == "__main__": main()