Upload alea/gen_hf3.py with huggingface_hub

alea/gen_hf3.py

@@ -0,0 +1,431 @@
+"""gen_hf3: second wave of real HF data — legal/policy/multi-hop/social.
+
+Targets the skills JevBench-hard actually tests: apply a long document's
+rules to a concrete case (contract-nli, casehold, ledgar), multi-hop
+retrieval (hotpot, 2wiki), algebra MCQ (aqua), commonsense/social
+(cosmos, siqa, swag, medmcqa), answerability (squad_v2).
+"""
+import argparse
+import json
+import random
+
+from datasets import load_dataset
+
+rng = random.Random(555)
+
+
+def choice_row(state, instructions, options_texts, correct_idx, family,
+               meta=None):
+    n = len(options_texts)
+    keys = ["opt_%d" % i for i in range(n)]
+    seen, fo, fk, ni = {}, [], [], None
+    for i, t in enumerate(options_texts):
+        t = str(t).strip()
+        if not t:
+            t = "(empty %d)" % i
+        if t in seen:
+            if i == correct_idx:
+                ni = seen[t]
+            continue
+        seen[t] = len(fo)
+        fo.append(t); fk.append(keys[i])
+        if i == correct_idx:
+            ni = len(fo) - 1
+    if ni is None or len(fo) < 2:
+        return None
+    tgt = [0.0] * len(fo); tgt[ni] = 1.0
+    return {"state": str(state)[:20000],
+            "questions": {"q0": {"type": "choice", "instructions": instructions,
+                                 "criteria": dict(zip(fk, fo))}},
+            "targets": {"q0": tgt}, "family": family, "meta": meta or {}}
+
+
+def noul_row(state, instructions, val, family, meta=None):
+    return {"state": str(state)[:20000],
+            "questions": {"q0": {"type": "noul", "instructions": instructions}},
+            "targets": {"q0": float(val)}, "family": family, "meta": meta or {}}
+
+
+def gen_contractnli(n, rng):
+    """Contract + hypothesis -> entailment/contradiction/neutral (3-way)."""
+    ds = None
+    for repo, cfg in (("coastalcph/lex_glue", "contract_nli"),
+                      ("jonathanli/lex-glue", "contract_nli")):
+        try:
+            ds = load_dataset(repo, cfg, split="train")
+            break
+        except Exception:
+            continue
+    if ds is None:
+        return []
+    out = []
+    label_names = ["entailment", "neutral", "contradiction"]
+    feats = ds.features.get("label")
+    if feats is not None and hasattr(feats, "names"):
+        label_names = feats.names
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        doc = (r.get("contract_text") or r.get("document") or "")[:9000]
+        hyp = r.get("hypothesis") or r.get("premise") or ""
+        lab = r.get("label")
+        if not doc or not hyp or lab is None:
+            continue
+        ci = int(lab)
+        if ci >= len(label_names):
+            continue
+        st = ("CONTRACT EXCERPT:\n%s\n\nHYPOTHESIS UNDER REVIEW:\n%s"
+              % (doc, hyp))
+        row = choice_row(st, "Decide the relationship between the contract "
+                         "text and the hypothesis.",
+                         ["the contract entails the hypothesis",
+                          "the contract neither entails nor contradicts it",
+                          "the contract contradicts the hypothesis"],
+                         {"entailment": 0, "neutral": 1,
+                          "contradiction": 2}.get(label_names[ci].lower(), 1),
+                         "hf_contractnli", meta={"src": "contract_nli"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_casehold(n, rng):
+    ds = None
+    for repo in ("coastalcph/lex_glue", "jonathanli/lex-glue"):
+        try:
+            ds = load_dataset(repo, "case_hold", split="train")
+            break
+        except Exception:
+            continue
+    if ds is None:
+        return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        ctx = str(r.get("context") or "")[:6000]
+        endings = [str(e) for e in (r.get("endings") or [])]
+        lab = int(r.get("label", -1))
+        if not ctx or len(endings) < 2 or lab < 0 or lab >= len(endings):
+            continue
+        row = choice_row("Case context:\n%s" % ctx,
+                         "Choose the holding that correctly completes the "
+                         "legal reasoning.", endings, lab, "hf_casehold",
+                         meta={"src": "lex_glue_case_hold"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_ledgar(n, rng):
+    """Contract clause -> provision type among sampled options."""
+    ds = None
+    for repo in ("coastalcph/lex_glue", "jonathanli/lex-glue"):
+        try:
+            ds = load_dataset(repo, "ledgar", split="train")
+            break
+        except Exception:
+            continue
+    if ds is None:
+        return []
+    names = ds.features["label"].names
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        true_name = names[int(r["label"])].replace("_", " ").lower()
+        k = rng.randint(3, 6)
+        others = rng.sample([x.replace("_", " ").lower() for x in names
+                             if x != names[int(r["label"])]], k)
+        opts = [true_name] + others
+        order = list(range(len(opts))); rng.shuffle(order)
+        shuffled = [opts[j] for j in order]
+        ci = shuffled.index(true_name)
+        st = "Contract clause:\n%s" % str(r.get("text") or "")[:3000]
+        row = choice_row(st, "Classify the provision type of this clause.",
+                         shuffled, ci, "hf_ledgar", meta={"src": "ledgar"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_unfair_tos(n, rng):
+    """ToS clause -> unfairness category."""
+    ds = None
+    for repo in ("coastalcph/lex_glue", "jonathanli/lex-glue"):
+        try:
+            ds = load_dataset(repo, "unfair_tos", split="train")
+            break
+        except Exception:
+            continue
+    if ds is None:
+        return []
+    names = ds.features["label"].names
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        lab = int(r["label"])
+        txt = str(r.get("text") or "")[:3000]
+        if not txt:
+            continue
+        opts = [x.replace("_", " ") for x in names]
+        row = choice_row("Terms-of-service clause:\n%s" % txt,
+                         "Classify the unfairness category of this clause.",
+                         opts, lab, "hf_unfair_tos", meta={"src": "unfair_tos"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_hotpot(n, rng):
+    try:
+        ds = load_dataset("hotpotqa/hotpot_qa", "distractor", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("hotpot_qa", "distractor", split="train",
+                              trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        # build a passage bundle from context titles/sentences
+        ctx = r.get("context") or {}
+        titles = ctx.get("title") or []
+        sents = ctx.get("sentences") or []
+        parts = []
+        for t, ss in zip(titles[:8], sents[:8]):
+            parts.append("%s: %s" % (t, " ".join(ss[:4])))
+        st = ("Passages:\n%s\n\nQuestion: %s" % ("\n".join(parts),
+                                                 r["question"]))
+        ans = r.get("answer", "")
+        if not ans or len(ans) > 120:
+            continue
+        # distractors from other answers
+        oi = idxs[rng.randint(0, len(idxs) - 1)]
+        wrong = []
+        while len(wrong) < 3:
+            w = ds[oi].get("answer", "")
+            if w and w != ans and len(w) < 120 and w not in wrong:
+                wrong.append(w)
+            oi = idxs[rng.randint(0, len(idxs) - 1)]
+        opts = [ans] + wrong
+        order = list(range(4)); rng.shuffle(order)
+        shuffled = [opts[j] for j in order]
+        ci = shuffled.index(ans)
+        row = choice_row(st, "Choose the answer that the passages jointly "
+                         "support.", shuffled, ci, "hf_hotpot",
+                         meta={"src": "hotpot"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_aqua(n, rng):
+    try:
+        ds = load_dataset("deepmind/aqua_rat", "raw", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("aqua_rat", split="train",
+                              trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    letter = "abcde"
+    for r in ds:
+        if len(out) >= n:
+            break
+        opts = r.get("options") or []
+        opts = [o[2:].strip() if len(o) > 2 and o[1] == ")" else o.strip()
+                for o in opts]
+        if len(opts) != 5:
+            continue
+        ci = letter.find(str(r.get("correct", "")).lower())
+        if ci < 0:
+            continue
+        row = choice_row("Problem:\n%s" % r["question"].strip(),
+                         "Solve and choose the correct answer.", opts, ci,
+                         "hf_aqua", meta={"src": "aqua_rat"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_medmcqa(n, rng):
+    try:
+        ds = load_dataset("openlifescienceai/medmcqa", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("medmcqa", split="train", trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        opts = [r.get(k, "") for k in ("opa", "opb", "opc", "opd")]
+        cop = r.get("cop")
+        if not all(opts) or cop is None or int(cop) > 3:
+            continue
+        st = "Clinical question:\n%s" % (r.get("question") or "")
+        row = choice_row(st, "Choose the best answer.", opts, int(cop),
+                         "hf_medmcqa", meta={"src": "medmcqa"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_cosmos(n, rng):
+    try:
+        ds = load_dataset("allenai/cosmos_qa", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("cosmos_qa", split="train",
+                              trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        opts = [r.get("answer%d" % k, "") for k in range(4)]
+        lab = r.get("label")
+        if not all(opts) or lab is None:
+            continue
+        st = "Context:\n%s\n\nQuestion:\n%s" % (r.get("context", ""),
+                                                r.get("question", ""))
+        row = choice_row(st, "Choose the most plausible answer.", opts,
+                         int(lab), "hf_cosmos", meta={"src": "cosmos_qa"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_squad2(n, rng):
+    """Answerable vs unanswerable -> noul (abstention signal)."""
+    try:
+        ds = load_dataset("rajpurkar/squad_v2", split="train")
+    except Exception:
+        return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        ans = r.get("answers", {}).get("text") or []
+        st = "Passage:\n%s\n\nQuestion:\n%s" % (r["context"][:5000],
+                                                r["question"])
+        out.append(noul_row(st, "Is the question answerable from the "
+                            "passage?", len(ans) > 0, "hf_squad2_answerable",
+                            meta={"src": "squad_v2"}))
+    return out
+
+
+def gen_siqa(n, rng):
+    try:
+        ds = load_dataset("allenai/social_i_qa", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("social_i_qa", split="train",
+                              trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    for r in ds:
+        if len(out) >= n:
+            break
+        opts = [r.get("answerA", ""), r.get("answerB", ""), r.get("answerC", "")]
+        lab = r.get("label")
+        if not all(opts) or lab is None:
+            continue
+        st = "Situation:\n%s\n\nQuestion:\n%s" % (r.get("context", ""),
+                                                  r.get("question", ""))
+        row = choice_row(st, "Choose the best answer.", opts,
+                         int(lab) - 1, "hf_siqa", meta={"src": "siqa"})
+        if row:
+            out.append(row)
+    return out
+
+
+def gen_swag(n, rng):
+    try:
+        ds = load_dataset("allenai/swag", "regular", split="train")
+    except Exception:
+        try:
+            ds = load_dataset("swag", split="train", trust_remote_code=True)
+        except Exception:
+            return []
+    out = []
+    idxs = list(range(len(ds))); rng.shuffle(idxs)
+    for i in idxs:
+        if len(out) >= n:
+            break
+        r = ds[i]
+        opts = [r.get("ending%d" % k, "") for k in range(4)]
+        lab = r.get("label")
+        if not all(opts) or lab is None:
+            continue
+        st = "%s %s" % (r.get("startphrase", ""), r.get("sent1", ""))
+        row = choice_row(st, "Choose the most plausible continuation.", opts,
+                         int(lab), "hf_swag", meta={"src": "swag"})
+        if row:
+            out.append(row)
+    return out
+
+
+GENS = {
+    "ledgar": gen_ledgar,
+    "unfair_tos": gen_unfair_tos,
+    "casehold": gen_casehold,
+    "hotpot": gen_hotpot,
+    "aqua": gen_aqua,
+    "medmcqa": gen_medmcqa,
+    "squad2": gen_squad2,
+    "swag": gen_swag,
+}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="data/hf3.jsonl")
+    ap.add_argument("--per", type=int, default=5000)
+    ap.add_argument("--only", default="")
+    args = ap.parse_args()
+    rows = []
+    only = set(args.only.split(",")) if args.only else None
+    for name, fn in GENS.items():
+        if only and name not in only:
+            continue
+        try:
+            got = fn(args.per, rng)
+        except Exception as e:
+            print(name, "FAILED", type(e).__name__, str(e)[:120])
+            continue
+        print(name, len(got))
+        rows += got
+    rng.shuffle(rows)
+    with open(args.out, "w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    print("TOTAL", len(rows), "->", args.out)
+
+
+if __name__ == "__main__":
+    main()