Upload alea/gen_hf.py with huggingface_hub

alea/gen_hf.py

@@ -0,0 +1,721 @@
+"""HuggingFace datasets -> decision-model rows.
+
+Real human-labeled corpora, mostly DET (hard) targets — complementing the
+synthetic SOFT families. Lazy load via `datasets`, module-level cache, rows
+drawn with replacement like the other gen modules.
+
+Primitive mapping:
+  MCQ (sciq/arc/obqa/csqa/race/mmlu/hellaswag/winogrande/piqa) -> choice
+  topic cls (ag_news/dbpedia/yahoo/trec/emotion/banking77/finpb) -> choice
+  binary (sst2/cola/mrpc/wnli/qnli/rte/imdb/rt/amazon/paws/wic/boolq) -> noul
+  NLI (snli/mnli)              -> choice + shared-state noul probes
+  go_emotions (multi-label)    -> shared-state noul probes
+  ordinal (yelp stars/sst5/app_reviews) -> score (5-level)
+  stsb 0-5 similarity          -> regress (normal quantiles, annotator spread)
+  squad_v2                     -> noul answerability
+"""
+import math
+import random
+from statistics import NormalDist
+
+from .genbase import (generate, emit, q_choice, q_noul, q_score, q_regress,
+                      validate_row, write_jsonl)
+
+rng = random.Random()
+_ND = NormalDist()
+_CACHE = {}
+
+
+def _trunc(s, n):
+    s = " ".join(str(s).split())
+    if len(s) <= n:
+        return s
+    return s[:n].rsplit(" ", 1)[0] + "..."
+
+
+def _ds(key, *args, **kw):
+    """load_dataset with cache; kw['cols'] limits kept columns if given."""
+    if key not in _CACHE:
+        from datasets import load_dataset
+        cols = kw.pop("cols", None)
+        try:
+            ds = load_dataset(*args, **kw)
+        except Exception:
+            _CACHE[key] = []
+            return _CACHE[key]
+        rows = ds.to_list() if hasattr(ds, "to_list") else list(ds)
+        if cols:
+            rows = [{c: r.get(c) for c in cols} for r in rows]
+        _CACHE[key] = rows
+    return _CACHE[key]
+
+
+def _pick(rows):
+    return rows[rng.randrange(len(rows))]
+
+
+def _onehot(n, k):
+    t = [0.0] * n
+    t[k] = 1.0
+    return t
+
+
+def _shuffle_opts(options, k):
+    """Return (shuffled_options, new_index_of_true)."""
+    idx = list(range(len(options)))
+    rng.shuffle(idx)
+    return [options[i] for i in idx], idx.index(k)
+
+
+# ---------------------------------------------------------------------------
+# MCQ -> choice
+# ---------------------------------------------------------------------------
+
+_SCIQ_Q = ["Pick the correct answer.", "Which answer is correct?",
+           "Choose the right answer to this science question.",
+           "Select the correct option."]
+_ARC_Q = ["Choose the correct answer.", "Which option correctly answers the question?",
+         "Select the right answer.", "Pick the answer."]
+_OBQA_Q = ["Which fact answers the question?", "Choose the correct answer.",
+           "Select the right option.", "Pick the correct answer."]
+_CSQA_Q = ["Choose the most sensible answer.", "Which option best answers the question?",
+          "Pick the correct answer.", "Select the best answer."]
+_RACE_Q = ["Answer the question about the passage.",
+           "Choose the correct answer based on the article.",
+           "Which option best answers the question?", "Pick the right answer."]
+_MMLU_Q = ["Choose the correct answer.", "Select the right answer.",
+           "Which option is correct?", "Pick the best answer."]
+_HS_Q = ["Which ending continues the passage most sensibly?",
+         "Pick the most plausible continuation.",
+         "Choose the ending that makes the most sense.",
+         "Select the most likely continuation."]
+
+
+def gen_hf_sciq():
+    r = _pick(_ds("sciq", "allenai/sciq", split="train",
+                  cols=["question", "correct_answer", "distractor1",
+                        "distractor2", "distractor3", "support"]))
+    options = [r["correct_answer"], r["distractor1"], r["distractor2"],
+               r["distractor3"]]
+    options, k = _shuffle_opts([_trunc(o, 120) for o in options], 0)
+    sup = _trunc(r.get("support") or "", 400)
+    state = ((f"Passage: {sup}\n" if sup else "")
+             + f"Question: {_trunc(r['question'], 200)}")
+    return state, [q_choice("ans", rng.choice(_SCIQ_Q), options,
+                            _onehot(len(options), k))]
+
+
+def _gen_arc(cfg):
+    r = _pick(_ds(f"arc_{cfg}", "allenai/ai2_arc", cfg, split="train",
+                  cols=["question", "choices", "answerKey"]))
+    labels = r["choices"]["label"]
+    texts = [_trunc(t, 140) for t in r["choices"]["text"]]
+    if r["answerKey"] not in labels:
+        raise ValueError("bad key")
+    k = labels.index(r["answerKey"])
+    texts, k = _shuffle_opts(texts, k)
+    state = f"Question: {_trunc(r['question'], 250)}"
+    return state, [q_choice("ans", rng.choice(_ARC_Q), texts,
+                            _onehot(len(texts), k))]
+
+
+def gen_hf_arc_easy():
+    return _gen_arc("ARC-Easy")
+
+
+def gen_hf_arc_challenge():
+    return _gen_arc("ARC-Challenge")
+
+
+def gen_hf_openbookqa():
+    r = _pick(_ds("obqa", "allenai/openbookqa", "main", split="train",
+                  cols=["question_stem", "choices", "answerKey"]))
+    labels = r["choices"]["label"]
+    texts = [_trunc(t, 140) for t in r["choices"]["text"]]
+    if r["answerKey"] not in labels:
+        raise ValueError("bad key")
+    k = labels.index(r["answerKey"])
+    texts, k = _shuffle_opts(texts, k)
+    state = f"Question: {_trunc(r['question_stem'], 250)}"
+    return state, [q_choice("ans", rng.choice(_OBQA_Q), texts,
+                            _onehot(len(texts), k))]
+
+
+def gen_hf_csqa():
+    r = _pick(_ds("csqa", "tau/commonsense_qa", split="train",
+                  cols=["question", "choices", "answerKey"]))
+    labels = r["choices"]["label"]
+    texts = [_trunc(t, 140) for t in r["choices"]["text"]]
+    if r["answerKey"] not in labels:
+        raise ValueError("bad key")
+    k = labels.index(r["answerKey"])
+    texts, k = _shuffle_opts(texts, k)
+    state = f"Question: {_trunc(r['question'], 250)}"
+    return state, [q_choice("ans", rng.choice(_CSQA_Q), texts,
+                            _onehot(len(texts), k))]
+
+
+def gen_hf_race():
+    r = _pick(_ds("race", "ehovy/race", "all", split="train",
+                  cols=["article", "question", "options", "answer"]))
+    art = _trunc(r["article"], 900)
+    q = r["question"].replace("_", "_____")
+    options = [_trunc(o, 140) for o in r["options"]]
+    k = "ABCD".index(r["answer"])
+    state = f"Article: {art}\nQuestion: {_trunc(q, 200)}"
+    return state, [q_choice("ans", rng.choice(_RACE_Q), options,
+                            _onehot(len(options), k))]
+
+
+def gen_hf_mmlu():
+    r = _pick(_ds("mmlu", "cais/mmlu", "all", split="test",
+                  cols=["subject", "question", "choices", "answer"]))
+    options = [_trunc(o, 160) for o in r["choices"]]
+    subj = r["subject"].replace("_", " ")
+    state = (f"Subject: {subj}\nQuestion: {_trunc(r['question'], 300)}")
+    return state, [q_choice("ans", rng.choice(_MMLU_Q), options,
+                            _onehot(len(options), int(r["answer"])))]
+
+
+def gen_hf_hellaswag():
+    r = _pick(_ds("hellaswag", "Rowan/hellaswag", split="train",
+                  cols=["ctx", "endings", "label"]))
+    endings = [_trunc(e, 180) for e in r["endings"]]
+    state = f"Passage: {_trunc(r['ctx'], 500)}"
+    return state, [q_choice("end", rng.choice(_HS_Q), endings,
+                            _onehot(len(endings), int(r["label"])))]
+
+
+def gen_hf_winogrande():
+    r = _pick(_ds("winogrande", "allenai/winogrande", "winogrande_xl",
+                  split="train",
+                  cols=["sentence", "option1", "option2", "answer"]))
+    sent = r["sentence"].replace("_", "_____")
+    options, k = _shuffle_opts([r["option1"], r["option2"]],
+                               int(r["answer"]) - 1)
+    state = f"Sentence: {_trunc(sent, 250)}"
+    qs = [q_choice("fill", "Which option correctly fills the blank?",
+                   options, _onehot(2, k))]
+    if rng.random() < 0.4:
+        qs.append(q_noul("first", "Is the first listed option correct?",
+                         float(k == 0)))
+    return state, qs
+
+
+def gen_hf_piqa():
+    r = _pick(_ds("piqa", "nthngdy/piqa", split="train",
+                  cols=["goal", "sol1", "sol2", "label"]))
+    options, k = _shuffle_opts([_trunc(r["sol1"], 200),
+                                _trunc(r["sol2"], 200)], int(r["label"]))
+    state = f"Goal: {_trunc(r['goal'], 200)}"
+    return state, [q_choice("sol", "Which solution achieves the goal?",
+                            options, _onehot(2, k))]
+
+
+# ---------------------------------------------------------------------------
+# topic classification -> choice
+# ---------------------------------------------------------------------------
+
+_AGN_Q = ["Which topic does this article belong to?",
+          "Classify this news article.", "Pick the correct news category.",
+          "What is the subject of this article?"]
+_DBP_Q = ["Which category does this entity belong to?",
+          "Classify this description.", "Pick the correct category."]
+_YAH_Q = ["Which topic best fits this question?",
+          "Classify this question by subject.",
+          "Pick the most appropriate topic."]
+_EMO_Q = ["Which emotion does this text express?",
+          "Classify the emotion in this text.",
+          "Pick the dominant emotion."]
+_FIN_Q = ["Classify the sentiment of this financial text.",
+          "Is this text bearish, neutral or bullish?",
+          "Pick the sentiment of this finance post."]
+_BANK_Q = ["Which banking intent does this query express?",
+           "Classify this customer-service query.",
+           "Pick the correct intent label."]
+
+
+def gen_hf_ag_news():
+    r = _pick(_ds("ag_news", "fancyzhx/ag_news", split="train",
+                  cols=["text", "label"]))
+    classes = ["world", "sports", "business", "sci/tech"]
+    state = f"News article: {_trunc(r['text'], 450)}"
+    qs = [q_choice("topic", rng.choice(_AGN_Q), classes,
+                   _onehot(4, int(r["label"])))]
+    if rng.random() < 0.35:
+        c = rng.randrange(4)
+        qs.append(q_noul("is", f"Is this a {classes[c]} article?",
+                         float(int(r["label"]) == c)))
+    return state, qs
+
+
+def gen_hf_dbpedia():
+    r = _pick(_ds("dbpedia", "fancyzhx/dbpedia_14", split="train",
+                  cols=["title", "content", "label"]))
+    classes = ["company", "educational institution", "artist", "athlete",
+               "office holder", "mean of transportation", "building",
+               "natural place", "village", "animal", "plant", "album",
+               "film", "written work"]
+    state = (f"Title: {_trunc(r['title'], 80)}\n"
+             f"Description: {_trunc(r['content'], 350)}")
+    return state, [q_choice("cat", rng.choice(_DBP_Q), classes,
+                            _onehot(14, int(r["label"])))]
+
+
+def gen_hf_yahoo():
+    r = _pick(_ds("yahoo", "community-datasets/yahoo_answers_topics",
+                  split="train",
+                  cols=["question_title", "question_content", "topic"]))
+    classes = ["society & culture", "science & math", "health",
+               "education & reference", "computers & internet", "sports",
+               "business & finance", "entertainment & music",
+               "family & relationships", "politics & government"]
+    state = (f"Question: {_trunc(r['question_title'], 120)}\n"
+             f"Details: {_trunc(r['question_content'], 280)}")
+    return state, [q_choice("topic", rng.choice(_YAH_Q), classes,
+                            _onehot(10, int(r["topic"])))]
+
+
+def gen_hf_emotion():
+    r = _pick(_ds("emotion", "dair-ai/emotion", split="train",
+                  cols=["text", "label"]))
+    classes = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+    lab = int(r["label"])
+    state = f"Text: {_trunc(r['text'], 350)}"
+    qs = [q_choice("emo", rng.choice(_EMO_Q), classes, _onehot(6, lab))]
+    if rng.random() < 0.4:                      # multi-probe on same state
+        c = rng.randrange(6)
+        qs.append(q_noul("is", f"Does this text express {classes[c]}?",
+                         float(lab == c)))
+    return state, qs
+
+
+def gen_hf_financial():
+    r = _pick(_ds("finpb", "zeroshot/twitter-financial-news-sentiment",
+                  split="train", cols=["text", "label"]))
+    classes = ["bearish", "neutral", "bullish"]
+    lab = int(r["label"])
+    state = f"Financial tweet: {_trunc(r['text'], 300)}"
+    qs = [q_choice("sent", rng.choice(_FIN_Q), classes, _onehot(3, lab))]
+    if rng.random() < 0.35:
+        qs.append(q_noul("neg", "Is this text bearish in tone?",
+                         float(lab == 0)))
+    return state, qs
+
+
+def gen_hf_banking77():
+    rows = _ds("banking77", "mteb/banking77", split="train",
+               cols=["text", "label", "label_text"])
+    r = _pick(rows)
+    lab = int(r["label"])
+    true_name = str(r["label_text"]).replace("_", " ")
+    # full 77-way option set is a stress test; 12-way subset keeps length sane
+    pool = list({str(x["label_text"]).replace("_", " ")
+                 for x in rng.sample(rows, min(60, len(rows)))} - {true_name})
+    options = rng.sample(pool, min(11, len(pool))) + [true_name]
+    options, k = _shuffle_opts(options, len(options) - 1)
+    state = f"Customer query: {_trunc(r['text'], 250)}"
+    return state, [q_choice("intent", rng.choice(_BANK_Q), options,
+                            _onehot(len(options), k))]
+
+
+# ---------------------------------------------------------------------------
+# binary -> noul
+# ---------------------------------------------------------------------------
+
+def _binary_gen(key, loader, state_fmt, qlist, second=None, extra=None):
+    r = _pick(_ds(key, *loader["args"], **loader["kw"]))
+    y = float(r["label"])
+    state = state_fmt(r)
+    instr, pol = qlist[rng.randrange(len(qlist))]
+    qs = [q_noul("y", instr, y if pol else 1.0 - y)]
+    if second and rng.random() < 0.35:
+        qs.append(q_choice("cls", second[0], second[1],
+                           [1.0 - y if pol else y, y if pol else 1.0 - y]))
+    if extra and rng.random() < 0.4:
+        q = extra(r)
+        if q:
+            qs.append(q)
+    return state, qs
+
+
+_SST2_Q = [("Is this review positive?", 1), ("Does this review express praise?", 1),
+           ("Is this a favorable review?", 1), ("Is this review negative?", 0)]
+_COLA_Q = [("Is this sentence grammatically acceptable?", 1),
+           ("Would a native speaker find this sentence grammatical?", 1),
+           ("Is this sentence ungrammatical?", 0)]
+_MRPC_Q = [("Are these two sentences paraphrases?", 1),
+           ("Do these sentences mean the same thing?", 1),
+           ("Are these sentences semantically equivalent?", 1)]
+_QNLI_Q = [("Does the sentence answer the question?", 1),
+           ("Is the question answered by the sentence?", 1),
+           ("Does the sentence fail to answer the question?", 0)]
+_RTE_Q = [("Does the premise entail the hypothesis?", 1),
+          ("Is the hypothesis supported by the premise?", 1),
+          ("Can we conclude the hypothesis from the premise?", 1)]
+_WNLI_Q = [("Does the first sentence entail the second?", 1),
+           ("Is the second sentence implied by the first?", 1)]
+_IMDB_Q = [("Is this movie review positive?", 1),
+           ("Did the reviewer like this film?", 1),
+           ("Is this review negative?", 0)]
+_RT_Q = [("Is this review positive?", 1), ("Is this a fresh review?", 1),
+         ("Is this review rotten?", 0)]
+_AMZ_Q = [("Is this product review positive?", 1),
+          ("Is the customer satisfied?", 1), ("Is this review negative?", 0)]
+_PAWS_Q = [("Are these sentences paraphrases?", 1),
+           ("Do these two sentences have the same meaning?", 1)]
+_WIC_Q = [("Does the highlighted word mean the same in both sentences?", 1),
+          ("Is the target word used with the same sense in both sentences?", 1)]
+_BOOLQ_Q = [("Is the correct answer to the question 'yes'?", 1),
+            ("Would the passage answer yes to this question?", 1)]
+
+
+def gen_hf_sst2():
+    return _binary_gen("sst2", {"args": ("nyu-mll/glue", "sst2"),
+                                "kw": {"split": "train",
+                                       "cols": ["sentence", "label"]}},
+                       lambda r: f"Review excerpt: {_trunc(r['sentence'], 300)}",
+                       _SST2_Q, second=("Classify the sentiment.",
+                                        ["negative", "positive"]))
+
+
+def gen_hf_cola():
+    return _binary_gen("cola", {"args": ("nyu-mll/glue", "cola"),
+                                "kw": {"split": "train",
+                                       "cols": ["sentence", "label"]}},
+                       lambda r: f"Sentence: {_trunc(r['sentence'], 250)}",
+                       _COLA_Q)
+
+
+def gen_hf_mrpc():
+    return _binary_gen(
+        "mrpc", {"args": ("nyu-mll/glue", "mrpc"),
+                 "kw": {"split": "train",
+                        "cols": ["sentence1", "sentence2", "label"]}},
+        lambda r: (f"Sentence A: {_trunc(r['sentence1'], 250)}\n"
+                   f"Sentence B: {_trunc(r['sentence2'], 250)}"),
+        _MRPC_Q)
+
+
+def gen_hf_qnli():
+    return _binary_gen(
+        "qnli", {"args": ("nyu-mll/glue", "qnli"),
+                 "kw": {"split": "train",
+                        "cols": ["question", "sentence", "label"]}},
+        lambda r: (f"Question: {_trunc(r['question'], 200)}\n"
+                   f"Sentence: {_trunc(r['sentence'], 300)}"),
+        _QNLI_Q)
+
+
+def gen_hf_rte():
+    return _binary_gen(
+        "rte", {"args": ("nyu-mll/glue", "rte"),
+                "kw": {"split": "train",
+                       "cols": ["premise", "hypothesis", "label"]}},
+        lambda r: (f"Premise: {_trunc(r['premise'], 300)}\n"
+                   f"Hypothesis: {_trunc(r['hypothesis'], 200)}"),
+        _RTE_Q)
+
+
+def gen_hf_wnli():
+    return _binary_gen(
+        "wnli", {"args": ("nyu-mll/glue", "wnli"),
+                 "kw": {"split": "train",
+                        "cols": ["sentence1", "sentence2", "label"]}},
+        lambda r: (f"Sentence 1: {_trunc(r['sentence1'], 250)}\n"
+                   f"Sentence 2: {_trunc(r['sentence2'], 250)}"),
+        _WNLI_Q)
+
+
+def gen_hf_imdb():
+    return _binary_gen("stanfordnlp/imdb", {"args": ("stanfordnlp/imdb",),
+                                "kw": {"split": "train",
+                                       "cols": ["text", "label"]}},
+                       lambda r: f"Movie review: {_trunc(r['text'], 600)}",
+                       _IMDB_Q, second=("Classify the review.",
+                                        ["negative", "positive"]))
+
+
+def gen_hf_rotten():
+    return _binary_gen("rt", {"args": ("cornell-movie-review-data/rotten_tomatoes",),
+                              "kw": {"split": "train",
+                                     "cols": ["text", "label"]}},
+                       lambda r: f"Review: {_trunc(r['text'], 300)}",
+                       _RT_Q, second=("Classify the review.",
+                                      ["rotten", "fresh"]))
+
+
+def gen_hf_amazon():
+    return _binary_gen("amz", {"args": ("fancyzhx/amazon_polarity",),
+                               "kw": {"split": "train",
+                                      "cols": ["content", "label"]}},
+                       lambda r: f"Product review: {_trunc(r['content'], 500)}",
+                       _AMZ_Q, second=("Classify the review.",
+                                       ["negative", "positive"]))
+
+
+def gen_hf_paws():
+    return _binary_gen(
+        "paws", {"args": ("google-research-datasets/paws", "labeled_final"),
+                 "kw": {"split": "train",
+                        "cols": ["sentence1", "sentence2", "label"]}},
+        lambda r: (f"Sentence A: {_trunc(r['sentence1'], 250)}\n"
+                   f"Sentence B: {_trunc(r['sentence2'], 250)}"),
+        _PAWS_Q)
+
+
+def gen_hf_wic():
+    def st(r):
+        w = r["word"]
+        return (f"Word: '{w}'\nSentence A: {_trunc(r['sentence1'], 220)}\n"
+                f"Sentence B: {_trunc(r['sentence2'], 220)}")
+    return _binary_gen(
+        "wic", {"args": ("aps/super_glue", "wic"),
+                "kw": {"split": "train",
+                       "cols": ["word", "sentence1", "sentence2", "label"]}},
+        st, _WIC_Q)
+
+
+def gen_hf_boolq():
+    r = _pick(_ds("boolq", "aps/super_glue", "boolq", split="train",
+                  cols=["question", "passage", "label"]))
+    y = float(r["label"])
+    state = (f"Passage: {_trunc(r['passage'], 500)}\n"
+             f"Question: {_trunc(r['question'], 200)}")
+    instr, pol = _BOOLQ_Q[rng.randrange(len(_BOOLQ_Q))]
+    qs = [q_noul("ans", instr, y if pol else 1.0 - y)]
+    if rng.random() < 0.3:
+        qs.append(q_choice("yn", "What is the correct answer?",
+                           ["yes", "no"], [y, 1.0 - y]))
+    return state, qs
+
+
+# ---------------------------------------------------------------------------
+# NLI -> choice + shared-state probes
+# ---------------------------------------------------------------------------
+
+_NLI_Q = ["What is the relationship between premise and hypothesis?",
+          "Classify the entailment relation.",
+          "Does the premise entail, contradict, or leave neutral the hypothesis?"]
+
+
+def _nli_gen(key, cfg):
+    rows = _ds(key, *cfg[0], **cfg[1])
+    while True:
+        r = _pick(rows)
+        lab = int(r["label"])
+        if lab >= 0:                       # snli has -1 unlabeled rows
+            break
+    classes = ["entailment", "neutral", "contradiction"]
+    state = (f"Premise: {_trunc(r['premise'], 350)}\n"
+             f"Hypothesis: {_trunc(r['hypothesis'], 180)}")
+    qs = [q_choice("rel", rng.choice(_NLI_Q), classes, _onehot(3, lab))]
+    # shared-state probes: ask about the other relations on the SAME state
+    probes = rng.sample(range(3), k=rng.choice([1, 2]))
+    for i, p in enumerate(probes):
+        qs.append(q_noul(
+            f"is{p}", f"Is the relation '{classes[p]}'?",
+            float(lab == p)))
+    return state, qs
+
+
+def gen_hf_snli():
+    return _nli_gen("snli", (("stanfordnlp/snli",), {"split": "train",
+                                         "cols": ["premise", "hypothesis",
+                                                  "label"]}))
+
+
+def gen_hf_mnli():
+    return _nli_gen("mnli", (("nyu-mll/glue", "mnli"), {"split": "train",
+                                                "cols": ["premise",
+                                                         "hypothesis",
+                                                         "label"]}))
+
+
+def gen_hf_goemotions():
+    rows = _ds("goemo", "google-research-datasets/go_emotions", "simplified",
+               split="train", cols=["text", "labels"])
+    if not rows:
+        raise ValueError("empty")
+    r = _pick(rows)
+    labs = set(r["labels"]) or {27}        # empty -> neutral (id 27)
+    names = ["admiration", "amusement", "anger", "annoyance", "approval",
+             "caring", "confusion", "curiosity", "desire", "disappointment",
+             "disapproval", "disgust", "embarrassment", "excitement", "fear",
+             "gratitude", "grief", "joy", "love", "nervousness", "optimism",
+             "pride", "realization", "relief", "remorse", "sadness",
+             "surprise", "neutral"]
+    state = f"Text: {_trunc(r['text'], 350)}"
+    qs = []
+    pos = rng.choice(sorted(labs))
+    negs = rng.sample([i for i in range(28) if i not in labs],
+                      k=rng.choice([1, 2]))
+    for i, p in enumerate([pos] + negs):
+        qs.append(q_noul(f"e{i}",
+                         f"Does this text express {names[p]}?",
+                         float(p in labs)))
+    if rng.random() < 0.5:
+        c = rng.choice(sorted(labs))
+        qs.append(q_noul("cls", f"Is {names[c]} among the emotions?",
+                         1.0))
+    return state, qs
+
+
+# ---------------------------------------------------------------------------
+# ordinal -> score  (5 levels)
+# ---------------------------------------------------------------------------
+
+_STAR_LV = ["1 star", "2 stars", "3 stars", "4 stars", "5 stars"]
+_YELP_Q = ["How many stars did the reviewer give?",
+           "Rate this review from 1 to 5 stars.",
+           "What star rating does this review correspond to?"]
+_SST5_LV = ["very negative", "negative", "neutral", "positive",
+            "very positive"]
+_SST5_Q = ["Classify the sentiment on a five-point scale.",
+           "Rate the sentiment of this sentence.",
+           "Pick the sentiment level."]
+_APP_Q = ["How many stars did the user give this app?",
+          "Rate this app review from 1 to 5 stars.",
+          "What star rating does this review show?"]
+
+
+def gen_hf_yelp():
+    r = _pick(_ds("yelp", "Yelp/yelp_review_full", split="train",
+                  cols=["text", "label"]))
+    lab = int(r["label"])                  # 0-4 -> 1-5 stars
+    state = f"Yelp review: {_trunc(r['text'], 500)}"
+    qs = [q_score("stars", rng.choice(_YELP_Q), _STAR_LV, _onehot(5, lab))]
+    if rng.random() < 0.3:
+        qs.append(q_noul("pos", "Is this a positive review (4-5 stars)?",
+                         float(lab >= 3)))
+    return state, qs
+
+
+def gen_hf_sst5():
+    r = _pick(_ds("sst5", "SetFit/sst5", split="train",
+                  cols=["text", "label"]))
+    lab = int(r["label"])
+    state = f"Sentence: {_trunc(r['text'], 300)}"
+    return state, [q_score("sent", rng.choice(_SST5_Q), _SST5_LV,
+                           _onehot(5, lab))]
+
+
+def gen_hf_app_reviews():
+    r = _pick(_ds("apprev", "sealuzh/app_reviews", split="train",
+                  cols=["review", "star"]))
+    lab = int(r["star"]) - 1               # 1-5 -> 0-4
+    state = f"App store review: {_trunc(r['review'], 400)}"
+    qs = [q_score("stars", rng.choice(_APP_Q), _STAR_LV, _onehot(5, lab))]
+    if rng.random() < 0.3:
+        qs.append(q_noul("pos", "Is this a positive review (4-5 stars)?",
+                         float(lab >= 3)))
+    return state, qs
+
+
+# ---------------------------------------------------------------------------
+# continuous -> regress
+# ---------------------------------------------------------------------------
+
+def _bucket_quantiles(lo, hi):
+    """19 quantiles of Uniform(lo, hi)."""
+    taus = [0.05 + 0.05 * i for i in range(19)]
+    return [lo + t * (hi - lo) for t in taus]
+
+
+def gen_hf_stsb():
+    r = _pick(_ds("stsb", "nyu-mll/glue", "stsb", split="train",
+                  cols=["sentence1", "sentence2", "label"]))
+    score = float(r["label"])              # 0-5 human similarity
+    state = (f"Sentence A: {_trunc(r['sentence1'], 250)}\n"
+             f"Sentence B: {_trunc(r['sentence2'], 250)}")
+    # model annotator disagreement as Normal(score, 0.6) clipped to [0,5]
+    sd = 0.6
+    taus = [0.05 + 0.05 * i for i in range(19)]
+    qs19 = [min(5.0, max(0.0, score + _ND.inv_cdf(t) * sd)) for t in taus]
+    qs = [q_regress("sim", "Predict the semantic similarity score (0-5).",
+                    qs19, unit="similarity points")]
+    if rng.random() < 0.35:
+        thr = rng.choice([1.0, 2.0, 3.0, 4.0])
+        qs.append(q_noul("hi", f"Is the similarity above {thr}?",
+                         float(score > thr)))
+    return state, qs
+
+
+def gen_hf_yelp_reg():
+    """Star rating -> regress on bucket uncertainty (uniform within star)."""
+    r = _pick(_ds("yelp", "Yelp/yelp_review_full", split="train",
+                  cols=["text", "label"]))
+    lab = int(r["label"])                  # 0-4
+    state = f"Yelp review: {_trunc(r['text'], 500)}"
+    lo, hi = float(lab), float(lab + 1)
+    qs = [q_regress("stars", "Predict the star rating (0-5 scale).",
+                    _bucket_quantiles(lo, hi), unit="stars")]
+    return state, qs
+
+
+# ---------------------------------------------------------------------------
+# squad_v2 -> answerability noul
+# ---------------------------------------------------------------------------
+
+def gen_hf_squad2():
+    r = _pick(_ds("squad2", "rajpurkar/squad_v2", split="train",
+                  cols=["context", "question", "answers"]))
+    answerable = len(r["answers"]["text"]) > 0
+    state = (f"Context: {_trunc(r['context'], 600)}\n"
+             f"Question: {_trunc(r['question'], 200)}")
+    qs = [q_noul("ans", "Is this question answerable from the context?",
+                 float(answerable))]
+    if answerable and rng.random() < 0.4:
+        ans = r["answers"]["text"][0]
+        qs.append(q_noul("short", f"Is the answer short (under 40 chars)?",
+                         float(len(ans) < 40)))
+    return state, qs
+
+
+FAMILIES = {
+    # MCQ
+    "hf_sciq": gen_hf_sciq, "hf_arc_easy": gen_hf_arc_easy,
+    "hf_arc_chal": gen_hf_arc_challenge, "hf_obqa": gen_hf_openbookqa,
+    "hf_csqa": gen_hf_csqa, "hf_race": gen_hf_race,
+    "hf_mmlu": gen_hf_mmlu, "hf_hellaswag": gen_hf_hellaswag,
+    "hf_winogrande": gen_hf_winogrande, "hf_piqa": gen_hf_piqa,
+    # topic cls
+    "hf_ag_news": gen_hf_ag_news, "hf_dbpedia": gen_hf_dbpedia,
+    "hf_emotion": gen_hf_emotion, "hf_financial": gen_hf_financial,
+    "hf_banking77": gen_hf_banking77,
+    # binary
+    "hf_sst2": gen_hf_sst2, "hf_cola": gen_hf_cola,
+    "hf_mrpc": gen_hf_mrpc, "hf_qnli": gen_hf_qnli,
+    "hf_rte": gen_hf_rte, "hf_wnli": gen_hf_wnli,
+    "hf_imdb": gen_hf_imdb, "hf_rotten": gen_hf_rotten,
+    "hf_amazon": gen_hf_amazon, "hf_paws": gen_hf_paws,
+    "hf_wic": gen_hf_wic, "hf_boolq": gen_hf_boolq,
+    # NLI / multi-probe
+    "hf_snli": gen_hf_snli, "hf_mnli": gen_hf_mnli,
+    "hf_goemo": gen_hf_goemotions,
+    # ordinal
+    "hf_yelp": gen_hf_yelp, "hf_sst5": gen_hf_sst5,
+    "hf_app_rev": gen_hf_app_reviews,
+    # regress
+    "hf_stsb": gen_hf_stsb, "hf_yelp_reg": gen_hf_yelp_reg,
+    # answerability
+    "hf_squad2": gen_hf_squad2,
+}
+WEIGHTS = {k: 1.0 for k in FAMILIES}
+WEIGHTS.update({"hf_squad2": 0.6, "hf_app_rev": 0.7, "hf_banking77": 0.6,
+                "hf_mmlu": 0.8, "hf_goemo": 0.8, "hf_yelp_reg": 0.5})
+
+
+def make_rows(n, seed):
+    return generate(FAMILIES, WEIGHTS, n, seed, rng)
+
+
+if __name__ == "__main__":
+    rows = make_rows(20, 0)
+    seen = {}
+    for r in rows:
+        validate_row(r)
+        seen[r["family"]] = seen.get(r["family"], 0) + 1
+    print(f"{len(rows)} rows OK")
+    print(seen)
+