File size: 4,716 Bytes
1e80dec
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
"""Build the model-merging dataset from the repo's result files.

    python -m merge_dataset.build_dataset [--out results/merge_dataset/model-merging-benchmark]

Runs every adapter in merge_dataset/adapters/, de-duplicates model identities, validates the
linked tables, computes the derived summary, and writes a Hugging Face dataset folder:

    README.md (dataset card)  merges.csv  evaluations.csv  models.csv  summary.csv
    data/{merges,evaluations,models,summary}.parquet   configs/<family>.json   scripts/

Reads result files only; never modifies them. Nothing is uploaded.
"""
import argparse
import importlib
import json
import pkgutil
import shutil
from pathlib import Path

import pandas as pd

from . import adapters as adapters_pkg
from .calculate_metrics import coverage, summarise
from .export_flat import flatten
from .card import render
from .schema import EVALUATIONS, MERGES, MODELS
from .validate_results import validate

HERE = Path(__file__).resolve().parent
REPO = HERE.parent


def _frame(rows, cols):
    df = pd.DataFrame(rows)
    for c in cols:
        if c not in df.columns:
            df[c] = None
    return df[cols]


def _dedupe_models(models: pd.DataFrame) -> pd.DataFrame:
    """One row per model_id; take the first non-empty value of each column across adapters."""
    models = models.replace("", None)
    return models.groupby("model_id", as_index=False, sort=True).first()


def collect(repo: Path):
    parts, sources = {"models": [], "merges": [], "evaluations": []}, {}
    for mod in pkgutil.iter_modules(adapters_pkg.__path__):
        if mod.name.startswith("_"):
            continue
        a = importlib.import_module(f"{adapters_pkg.__name__}.{mod.name}")
        out = a.build(repo)
        for k in parts:
            parts[k].extend(out.get(k, []))
        sources[mod.name] = list(getattr(a, "SOURCES", []))
    models = _dedupe_models(_frame(parts["models"], MODELS))
    merges = _frame(parts["merges"], MERGES)
    evals = _frame(parts["evaluations"], EVALUATIONS)
    return models, merges, evals, sources


def write(out: Path, models, merges, evals, summary, sources):
    out.mkdir(parents=True, exist_ok=True)
    (out / "data").mkdir(exist_ok=True)
    (out / "configs").mkdir(exist_ok=True)
    for name, df in (("merges", merges), ("evaluations", evals), ("models", models), ("summary", summary)):
        df.to_csv(out / f"{name}.csv", index=False)
        df.astype({c: "string" for c in df.columns if df[c].dtype == object}).to_parquet(
            out / "data" / f"{name}.parquet", index=False)
    for fam, g in merges.groupby("experiment_family"):
        cfg = {"experiment_family": fam, "merges": len(g),
               "merge_methods": g["merge_method"].value_counts().to_dict(),
               "alignment_methods": g["alignment_method"].value_counts().to_dict(),
               "evaluation_status": g["evaluation_status"].value_counts().to_dict(),
               "source_files": sorted(set(g["source_file"].dropna()))}
        (out / "configs" / f"{fam}.json").write_text(json.dumps(cfg, indent=2, default=int))
    (out / "scripts").mkdir(exist_ok=True)
    for f in ("schema.py", "build_dataset.py", "calculate_metrics.py", "validate_results.py", "export_flat.py", "card.py"):
        shutil.copy2(HERE / f, out / "scripts" / f)
    (out / "sources.json").write_text(json.dumps(sources, indent=2))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--repo", default=str(REPO))
    ap.add_argument("--out", default=str(REPO / "results/huggingface_dataset"))
    args = ap.parse_args()
    models, merges, evals, sources = collect(Path(args.repo))
    errs = validate(models, merges, evals)
    for e in errs:
        print("INVALID:", e)
    summary = summarise(merges, evals)
    cov = coverage(merges, evals, summary)
    out = Path(args.out)
    write(out, models, merges, evals, summary, sources)
    flat = flatten(summary, merges, models, evals)
    flat.to_csv(Path(args.repo) / "results/merged_models.csv", index=False)
    flat.to_csv(out / "merged_models.csv", index=False)
    flat.astype({c: "string" for c in flat.columns if flat[c].dtype == object}).to_parquet(
        out / "data" / "merged_models.parquet", index=False)
    cov["merged_models_rows"] = len(flat)
    cov["merged_models_by_result_status"] = flat["result_status"].value_counts().to_dict()
    (out / "coverage.json").write_text(json.dumps(cov, indent=2))
    (out / "README.md").write_text(render(merges, evals, models, flat, cov))
    print(json.dumps(cov, indent=2))
    print(f"wrote {out}  ({'VALID' if not errs else f'{len(errs)} problems'})")
    return 1 if errs else 0


if __name__ == "__main__":
    raise SystemExit(main())