Add dataset card and release build script (draft for review)

README.md

@@ -0,0 +1,245 @@
+---
+license: other
+license_name: mixed
+pretty_name: Curation decision mix (draft)
+task_categories: [text-classification, zero-shot-classification]
+tags: [data-curation, decision-model, gliclass, provenance]
+size_categories: [100K<n<1M]
+configs:
+  - {config_name: all, data_files: "data/*/train.parquet", default: true}
+  - {config_name: base, data_files: data/base/train.parquet}
+  - {config_name: decisionbank, data_files: data/decisionbank/train.parquet}
+  - {config_name: prompt, data_files: data/prompt/train.parquet}
+  - {config_name: web, data_files: data/web/train.parquet}
+  - {config_name: nls, data_files: data/nls/train.parquet}
+  - {config_name: tool, data_files: data/tool/train.parquet}
+  - {config_name: harvard, data_files: data/harvard/train.parquet}
+  - {config_name: arxiv, data_files: data/arxiv/train.parquet}
+  - {config_name: procpile, data_files: data/procpile/train.parquet}
+---
+
+<!-- DRAFT 2026-10-28, private review PR. -->
+
+# Curation decision mix — draft
+
+The training data of `davanstrien/ultrabert-380m-curation`, a small classifier that answers curation questions about web pages, prompts,
+maths problems and library records ("what topic is this page?", "how educational is it?", "how hard is this
+problem?"). Each row is a text, a question, a set of options and a probability for each option. Every row records
+where it came from, who made its label and under which licence.
+
+| | |
+|---|---|
+| Rows | 516,964 released, from a 535,730-row training mix; 18,766 base rows without a verified open licence are left out (see Licences) |
+| Sources | 9: public task collections, DecisionBank, curation labels from web/prompt datasets, library catalogues, program-computed tasks |
+| Row shapes | decision rows `{state, question, target}` and GLiClass rows `{text, all_labels, true_labels, prompt}` |
+| Labels made by | dataset gold, library cataloguers, programs, and LLMs (named per source and per row) |
+| Licence | mixed, per row; web page text is **not** included (labels plus a pointer to the source row; rebuild snippet below) |
+| Trains | `davanstrien/ultrabert-380m-curation` (UltraBERT-380M + GLiClass head; 12,000 steps over this mix) |
+| Build | mix builder on Hugging Face Jobs (CPU), then `scripts/release_build.py` (in this repo) for the release; file checksum (sha256) `3a1d0fa84e7342f7…`; test sets fixed before the mix was built, and every row checked against them |
+
+```python
+import json
+from datasets import load_dataset
+ds = load_dataset("davanstrien/curation-decision-mix", "all", split="train")          # or one config per source, e.g. "decisionbank"
+ok = ds.filter(lambda r: r["licence_class"] == "permissive")        # filter by licence before reuse
+q = json.loads(ds[0]["question"])                                   # nested fields are JSON strings
+```
+
+---
+
+## Layout
+
+One config per source, plus `all`. Splitting by source keeps licence terms together, so a user can take only the parts
+whose terms suit them.
+
+| Config | Rows (training mix) | Shape |
+|---|---:|---|
+| `base` | 173,859 (192,625 in training; licence filter) | GLiClass |
+| `decisionbank` | 165,277 | decision |
+| `prompt` | 52,491 | decision |
+| `web` | 41,890 (labels only; `state` empty until rebuilt) | decision |
+| `nls` | 23,846 | GLiClass |
+| `tool` | 21,089 | GLiClass |
+| `harvard` | 13,918 | decision |
+| `arxiv` | 13,597 | GLiClass |
+| `procpile` | 10,997 | GLiClass |
+
+Columns (union of both shapes; unused fields are null):
+
+| Column | Meaning |
+|---|---|
+| `id` | stable row id; prefix names the source (`db/…`, `procpile-…`, `knowledgator/gliclass-v2.0:…`) |
+| `config`, `src` | source group and the finer origin (e.g. `db_bitext_support`, a tasksource task) |
+| `row_type` | `decision` or `gliclass` |
+| `teacher` | who made the label (e.g. `Llama-3.1-405B`, `cataloguer`, `program`, `50% source label + 50% Qwen3.8-27B`) |
+| `licence_class`, `licence` | `permissive` / `sa` (share-alike) / `publisher` (text not redistributed), and the licence id |
+| `state` | the input (decision rows): a string, or a record as a JSON string |
+| `question` | JSON string: `{type: noul|choice, instructions, criteria}`; `noul` = yes/no; `choice` options are `{key: description}`; graded scales use `level_<k>` keys, lowest first |
+| `target` | JSON string: probability per option (soft targets allowed; sums to 1 for single-answer rows) |
+| `text`, `all_labels`, `true_labels`, `prompt` | GLiClass rows: text, label list, `{label: score}` or a list (JSON string), optional prompt |
+| `multi_label` | true when several options can be correct (per-option yes/no loss in training) |
+| `source_dataset`, `source_row` | `web` rows only: source dataset and row index in its `train` split |
+
+Example decision row (DecisionBank, shortened):
+
+```json
+{"id": "db/decider/bitext_support/286978::q1", "src": "db_bitext_support", "row_type": "decision",
+ "teacher": "50% decider label + 50% Qwen3.8-27B", "licence_class": "sa", "licence": "cdla-sharing-1.0",
+ "state": "how do i remove several articles from order {{Order Number}}",
+ "question": {"type": "choice", "instructions": "What is the specific intent of this request?",
+              "criteria": {"change order": "change order", "get refund": "get refund", "...": "..."}},
+ "target": {"change order": 1.0, "get refund": 0.0, "...": 0.0}}
+```
+
+Example GLiClass row (procedural pile, shortened):
+
+```json
+{"id": "procpile-game_forced_win-89307", "row_type": "gliclass", "teacher": "program",
+ "text": "In this graph game, decide whether player can force a win. … The answer is Yes or No.",
+ "all_labels": ["No", "Yes"], "true_labels": {"No": 0.0, "Yes": 1.0}, "prompt": ""}
+```
+
+**Web text.** The `web` config carries labels only. `source_dataset` and `source_row` point at the row in the
+source dataset's `train` split; the training text was the first 3,000 characters. To rebuild it for your own use
+(do not redistribute it):
+
+```python
+src = {}
+def rebuild(r):
+    if r["source_dataset"] not in src:
+        src[r["source_dataset"]] = load_dataset(r["source_dataset"], split="train")
+    return {"state": src[r["source_dataset"]][r["source_row"]]["text"][:3000]}
+web = load_dataset("davanstrien/curation-decision-mix", "web", split="train").map(rebuild)
+```
+
+Row indices assume the source datasets are unchanged since October 2026.
+
+---
+
+## Sources
+
+| Source | Rows | What the rows ask | Labels made by | Licence |
+|---|---:|---|---|---|
+| base (tasksource + knowledgator GLiClass data) | 173,859 (192,625 trained on) | many public classification tasks | dataset gold; knowledgator gliclass-v2.0 / v3-logic (LLM-generated) | per source repo, in `licence`; only rows with a verified permissive, share-alike or other open licence are released (see Licences) |
+| DecisionBank-260k (jgeuter/DecisionBank) | 165,277 | public tasks, written and programmatic decision questions | 50 % source label + 50 % Qwen3.8-27B; Qwen3.8-27B with thinking; 50 % Jeff 1.0 teachers (Qwen3.6-27B, Qwen3.5-122B-A10B) + 50 % Qwen3.8-27B (4,188 rows); code | per row: CC BY / CC BY-SA, Apache, MIT, CC0 (public domain), CDLA-Sharing only (non-commercial, research-only, unknown and other terms dropped) |
+| prompt slice | 52,491 | NuminaMath-1.5 question type / problem type / validity; DeepMath-103K difficulty / topic; WebInstruct-verified answer type / category / difficulty; LMArena criteria and tags | dataset columns (NuminaMath, WebInstruct: labeller not documented); GPT-4o (DeepMath); LMArena classifiers | Apache-2.0; MIT; Apache-2.0; CC-BY-4.0 |
+| web slice (**ids and labels only**) | 41,890 | WebOrganizer topic and format; FineWeb-Edu educational value | Llama-3.1-405B (WebOrganizer; the annotation datasets state no licence); Llama-3-70B (FineWeb-Edu) | labels: none stated; ODC-By. Page text: publisher copyright, not included (rebuild snippet above) |
+| National Library of Scotland catalogue | 23,846 | subject areas of library records | National Library of Scotland cataloguers | CC0 |
+| tool lane | 21,089 | tool selection | program-computed | permissive |
+| Harvard modern catalogue | 13,918 | Library of Congress subject class, literary form, government publication | Harvard Library cataloguers (from their catalogue records) | CC0 |
+| arXiv | 13,597 | arXiv subject category | author-chosen categories | arXiv metadata (CC0) |
+| procedural pile | 10,997 | program-checkable reasoning | program-computed | CC BY 4.0 (attribute) |
+
+---
+
+## How the mix was designed
+
+The mix is the result of a series of screened experiments (2026-10-23 → 10-27). Each choice below states what it rests
+on: earlier decision-model reports, published curation work, or our own measurements. "Curation score" is the
+benchmark used for selection: the mean of 16 curation test sets, balanced by family (see the model card).
+
+**1. Start from a broad public base, cleaned by task identity.** The base follows the GLiClass v4 recipe
+(knowledgator): tasksource classification tasks plus knowledgator's GLiClass training sets, so the model keeps general
+zero-shot skill. Contamination was screened by task, not only by canary strings: tasksource re-hosts BIG-bench tasks
+without the canary, and whole sources (math_qa, cosmos_qa, vitaminc, qasc, social_i_qa, …) were removed (2.7 % of
+the pool).
+
+**2. Prefer clean, audited, family-covering data to volume.** Earlier decision-model reports found bulk open decision
+data neutral or harmful, gains staying inside the task families covered, and source audits worth more than extra rows.
+Our own runs agreed: adding bulk without audits did not help; diverse, audited sources did (+4 points over the base
+alone on a sample of a public decision benchmark suite). So every source was audited before training:
+- **Text-blind baselines** on every source (majority label, longest option, options-only ranker). A generated-schema
+  source that looked like +4.5 turned out to be mostly a "longest option is right" shortcut (real gain ≈ +2.3), so
+  sources with option-only leaks were fixed or dropped.
+- **Distractors weighted by gold frequency.** With uniformly sampled wrong options, a real-label source (arXiv)
+  leaked a label prior (+18 points over chance from the options alone). The Harvard rows needed the same fix
+  (options-only 52 % before it).
+- **Same writing style for every class.** A source where one class was human-written and the other LLM-written taught
+  "LLM style means unsupported" and was dropped.
+
+**3. Train on the labels real curation pipelines use.** The curation slices reuse public labels from curation work:
+WebOrganizer topic and format (Wettig et al., 2025, *Organize the Web*), FineWeb-Edu educational value (Penedo et
+al., 2024), and prompt tags from NuminaMath-1.5, DeepMath-103K, WebInstruct-verified and LMArena. Fixed-head
+classifiers trained on the same labels were used as a ceiling check before any claim (they still win their own
+labels: 0.87 / 0.83 vs 0.84 / 0.74 for WebOrganizer topic / format).
+
+**4. Keep the third-party labels; document them.** We tested replacing every LLM-made label with labels from a panel
+of open models (2 seeds). The panel matched the 405B topic labels well (0.815) but lost 5.1 curation-score points,
+almost all on graded axes (maths difficulty, educational value). Rubric-anchored prompts helped the panel (+0.07
+rank correlation against Omni-MATH human ratings) but did not close the gap. So the release keeps the original labels and
+states each labeller, model and licence (Sources table and the `teacher` column).
+
+**5. Add human-made labels where they exist.** Library catalogue records (National Library of Scotland, Harvard) carry
+labels made by cataloguers. Harvard rows lifted an unseen library scheme by +4.6 accuracy (3 seeds, all 9 seed pairs
+positive) without hurting the curation score; the cost to watch is the Aegis safety test set (−4.7).
+
+**6. Add DecisionBank, licence-filtered.** DecisionBank rows added +0.70 curation-score points at equal steps and +0.77 at equal passes
+over the other rows (3 seeds each, all 9 pairs positive), mostly on evals whose gold is independent of any training
+labeller. Only rows with allowed licences were kept; the HelpSteer families were dropped because they are held-out test sets.
+
+**7. Program-computed lanes for reasoning and tools.** Procedural reasoning tasks, tool selection and arXiv
+categories have labels that are computed or author-chosen, so they carry no labeller bias. They help general decision
+tasks more than the curation score.
+
+### How train and eval were split
+
+- **Evals first.** The eval sets (v3: 40 sets, 72,533 rows) were frozen before any mix was built, and every mix was
+  decontaminated against all of them (exact, normalised, prefix, number-stripped skeleton, containment, 13-gram).
+- **Hold out whole sources and schemes, not random rows.** Dev sets drawn from the training pool overestimate held-out
+  scores (earlier reports saw dev scores rise while scores on private test sets fell, and data shaped like a benchmark
+  inflate that benchmark's public score). So held-out test sets
+  are whole sources (HelpSteer2/3, Polaris, Aegis, WildGuard) and label schemes not seen in training (the item types of
+  US company filings, SEC form 8-K; a library item-form scheme).
+- **Separate same-labeller from independent gold.** Where an eval's gold comes from the same LLM that labelled
+  training rows (WebOrganizer, FineWeb-Edu, DeepMath), it partly measures agreement with that labeller. The fair
+  comparison uses independent gold (Omni-MATH human ratings, Essential-Web), reported apart in the model card.
+- **Seeds and review.** Each data choice was screened with ≥ 2 training seeds and claimed with ≥ 3; every claimed result was reviewed by
+  two independent reviewers before adoption.
+
+## Decontamination
+
+Every row was checked against every text in the test sets (version v3). Removed: 1,562 base rows (478 overlaps +
+1,084 rows from HelpSteer3 sources, a held-out test source), 1,035 DecisionBank rows (mostly HelpSteer3 / Aegis
+prompts), 1 Harvard row; the HelpSteer families of DecisionBank were dropped before the build. A 12-gram
+near-duplicate check found 15 of 1,038 HelpSteer2 and 15 of 1,832 HelpSteer3 eval items sharing text with a
+DecisionBank row. The catalogue test sets were kept out by id and title when the Harvard and National Library of Scotland sources were built.
+
+## Licences
+
+Licence classes in the training mix: permissive 396,026 rows, share-alike 97,814, publisher terms 41,890 (web text;
+trained on, never redistributed). DecisionBank's own parts are CC BY-SA 4.0; share-alike rows keep their licence in
+this dataset. The model is released under Apache-2.0 (share-alike data may train a permissively licensed model).
+
+Base rows, by the licence on the source repo's card (or, for tasksource tasks, the origin dataset's card; not legal
+advice): of 200,000 rows before decontamination, 178,084 verified permissive, 1,127 share-alike (CC BY-SA), 497 under
+other open licences (Mozilla Public License, Academic Free License), 13,263 not traced to an origin, 5,971 with no
+licence stated and 1,058 under the GPL. The model was trained on all of them. This dataset releases only the
+permissive, share-alike and other-open rows (173,859 after decontamination); the per-row licence is in `licence`.
+
+## Compute
+
+Every step ran on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs), with sources, mixes
+and test sets in Hugging Face storage buckets mounted into each job.
+- **Building the data** (source conversion, licence filtering, decontamination, the mix itself) ran on CPU jobs; the
+  final mix build takes about 16 minutes.
+- **Labelling experiments** (open-model panels, rubric and pairwise checks; see design note 4) called LLMs through
+  Hugging Face Inference Providers from Jobs. Those labels are not in the final mix.
+- **Training and evaluation** of each data choice ran on single RTX PRO 6000 GPU jobs, about an hour per training run.
+- The release build (`scripts/release_build.py`) is a CPU job that reads the mix from a bucket and writes this repo.
+
+## Known issues
+
+- Several label sources are LLM outputs (named above and per row); the WebOrganizer annotation datasets carry no
+  licence statement; the Llama 3 / 3.1 licences apply to the Llama-made labels.
+- Use terms of the original sources apply to their rows; check `licence` / `src` per row before reuse.
+- Multilingual rows (DecisionBank) are present; the model was evaluated in English only.
+- Maths difficulty labels are the weakest question type (LLM-made; human ratings agree only moderately).
+
+## Notes for agents
+
+- Filter on `licence_class` / `licence` before redistributing any subset; never redistribute rebuilt `web` text.
+- `target` is a distribution, not a class index; take `argmax` for hard labels. Graded questions (`level_<k>` keys)
+  are ordered: use the expected level or a rank correlation (Spearman), not top-1 accuracy alone.
+- This release is not the exact training mix: 18,766 base rows are left out and web text is removed.
+- Evals are not in this dataset; they are listed by name in the model card. Do not train on Omni-MATH, Essential-Web,
+  HelpSteer, Polaris, Aegis or WildGuard if you want to compare with the model card.

scripts/release_build.py

@@ -0,0 +1,134 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["polars", "huggingface_hub>=1.32"]
+# ///
+"""Build the released dataset from the training mix (cur-cand v1) and upload it to a private dataset repo.
+
+One parquet per config (source group), under data/<config>/. Release rules:
+- base: keep rows whose source repo has a verified permissive, share-alike or other open licence
+  (analysis/release/base_licence_map.json); drop GPL, unresolved and no-licence rows. Fill `licence` per row.
+- web: page text is not redistributed; `state` is set to "" and `source_dataset` / `source_row` point at the
+  source row (train split) so the text can be rebuilt.
+- nested fields (state when it is a record, question, target, true_labels) are stored as JSON strings.
+usage (CPU Job, dm-curation mounted at /c): python release_build.py --repo davanstrien/<name> [--dry-run]
+"""
+
+import argparse
+import collections
+import json
+import tempfile
+from pathlib import Path
+
+import polars as pl
+from huggingface_hub import HfApi
+
+MIX = Path("/c/mixes/cur-cand/v1")
+LICMAP = Path("/c/analysis/release/base_licence_map.json")
+CONFIG = {
+    "base-r1g": "base", "decisionbank": "decisionbank", "prompt-slice-tpm": "prompt", "web-slice-tpm": "web",
+    "nls": "nls", "tool": "tool", "harvard-modern": "harvard", "fh-arxiv": "arxiv", "procpile": "procpile",
+}
+# Licence per config where the whole source shares one licence (dataset card, Sources table); None = per src.
+CONFIG_LICENCE = {"nls": "cc0-1.0", "harvard": "cc0-1.0", "arxiv": "cc0-1.0", "procpile": "cc-by-4.0"}
+# Licence by src prefix for configs that mix sources (dataset card, Sources table).
+SRC_LICENCE = {"numina_": "apache-2.0", "wi_": "apache-2.0", "dm_": "mit", "arena_": "cc-by-4.0",
+               "fineweb_edu": "odc-by", "weborganizer_": None,
+               "tool": "per package: mit / bsd / apache-2.0 / psf"}
+# Web rows: the id suffix is the row index in the source dataset's train split (scripts/cur_build.py).
+WEB_SOURCE = {"cur-wo-topic-": "WebOrganizer/TopicAnnotations-Llama-3.1-405B-FP8",
+              "cur-wo-format-": "WebOrganizer/FormatAnnotations-Llama-3.1-405B-FP8",
+              "cur-fwe-": "HuggingFaceFW/fineweb-edu-llama3-annotations"}
+COLUMNS = ["id", "config", "src", "row_type", "teacher", "licence_class", "licence", "state", "question", "target",
+           "text", "all_labels", "true_labels", "prompt", "multi_label", "source_dataset", "source_row"]
+
+
+def as_json(v):
+    return None if v is None else json.dumps(v, ensure_ascii=False, sort_keys=False)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo", required=True)
+    ap.add_argument("--dry-run", action="store_true")
+    args = ap.parse_args()
+
+    licmap = json.loads(LICMAP.read_text())
+    man = pl.read_parquet(MIX / "manifest.parquet", columns=["id", "source", "row_type"])
+    source_of = dict(zip(man["id"].to_list(), man["source"].to_list()))
+
+    rows = collections.defaultdict(list)
+    stats = collections.Counter()
+    extra_keys = collections.Counter()
+    no_licence = collections.Counter()
+    with open(MIX / "mix.jsonl") as f:
+        for line in f:
+            r = json.loads(line)
+            config = CONFIG[Path(source_of[r["id"]]).parent.name]
+            stats[f"{config}:in"] += 1
+            licence = r.get("licence") or CONFIG_LICENCE.get(config)
+            if licence is None:
+                for prefix, lic in SRC_LICENCE.items():
+                    if r.get("src", "").startswith(prefix):
+                        licence = lic
+                        break
+            if config == "base":
+                repo = "/".join(r["src"].split("/")[:2])
+                entry = licmap[repo]
+                if not entry["keep"]:
+                    stats[f"base:drop_{entry['status']}"] += 1
+                    continue
+                licence = entry["licence"]
+            row_type = "gliclass" if "all_labels" in r else "decision"
+            state = r.get("state")
+            source_dataset = source_row = None
+            if config == "web":
+                state = ""
+                prefix = next(p for p in WEB_SOURCE if r["id"].startswith(p))
+                source_dataset, source_row = WEB_SOURCE[prefix], int(r["id"][len(prefix):])
+            out = {
+                "id": r["id"], "config": config, "src": r.get("src"), "row_type": row_type,
+                "teacher": r.get("teacher"), "licence_class": r.get("licence_class"), "licence": licence,
+                "state": state if state is None or isinstance(state, str) else as_json(state),
+                "question": as_json(r.get("question")), "target": as_json(r.get("target")),
+                "text": r.get("text"), "all_labels": r.get("all_labels"),
+                "true_labels": as_json(r.get("true_labels")), "prompt": r.get("prompt"),
+                "multi_label": bool(r.get("multi_label", False)),
+                "source_dataset": source_dataset, "source_row": source_row,
+            }
+            for k in r:
+                if k not in out:
+                    extra_keys[k] += 1
+            if licence is None:
+                no_licence[(config, out["src"])] += 1
+            rows[config].append(out)
+            stats[f"{config}:out"] += 1
+
+    schema = {c: pl.Utf8 for c in COLUMNS}
+    schema["all_labels"] = pl.List(pl.Utf8)
+    schema["multi_label"] = pl.Boolean
+    schema["source_row"] = pl.Int64
+    print(json.dumps(dict(sorted(stats.items())), indent=1))
+    print("dropped keys (not released):", dict(extra_keys))
+    print("no licence (config, src):", no_licence.most_common())
+    print("total out:", sum(len(v) for v in rows.values()))
+    for config, rs in rows.items():
+        ex = {k: (v[:120] if isinstance(v, str) else v) for k, v in rs[0].items()}
+        print(config, json.dumps(ex, ensure_ascii=False)[:600])
+    if args.dry_run:
+        return
+
+    api = HfApi()
+    api.create_repo(args.repo, repo_type="dataset", private=True, exist_ok=True)
+    with tempfile.TemporaryDirectory() as d:
+        for config, rs in rows.items():
+            p = Path(d) / "data" / config
+            p.mkdir(parents=True)
+            pl.DataFrame(rs, schema=schema).write_parquet(p / "train.parquet")
+        (Path(d) / "release_stats.json").write_text(json.dumps(dict(sorted(stats.items())), indent=1))
+        api.upload_folder(repo_id=args.repo, repo_type="dataset", folder_path=d,
+                          commit_message="Add release build of the cur-cand v1 training mix")
+    print("uploaded", api.list_repo_files(args.repo, repo_type="dataset"))
+
+
+if __name__ == "__main__":
+    main()