Datasets:
Download scripts/build_pool.py from MINZIK77/midtraining-pool: direct link, hf CLI and curl.
- Browser
- Download file 34.8 kB
-
https://huggingface.co/datasets/MINZIK77/midtraining-pool/resolve/main/scripts/build_pool.py
- Command line
-
hf download hf://datasets/MINZIK77/midtraining-pool/scripts/build_pool.py
-
curl -L -o build_pool.py https://huggingface.co/datasets/MINZIK77/midtraining-pool/resolve/main/scripts/build_pool.py
34.8 kB
| """Build the mid-training candidate pool (Hub dataset MINZIK77/midtraining-pool), one config per source. | |
| usage: | |
| python build_pool.py probe NAME [--rows 40] # parse a few rows of one file, print a normalized row and counts | |
| python build_pool.py build NAME [NAME ...] [--upload] [--workers N] | |
| # all files -> OUT/data/NAME/train-*.parquet + OUT/stats/NAME.json | |
| python build_pool.py upload [NAME ...] # data + stats + this script -> the Hub repo (README: make_card.py) | |
| Each row is one agent trajectory in one schema for all sources: | |
| id, source, task_id, repo, scaffold, outcome, group, messages[{role, content, reasoning, tool_calls, tool_call_id, | |
| name}], tools, n_messages, n_chars, n_tokens_sigdig, n_tokens_smollm3, content_hash | |
| - id: source/file/row for parquet sources, source/file@byte_offset for jsonl sources. | |
| - messages keep the source text. Roles are mapped to system / user / assistant / tool. tool_calls is a JSON list of | |
| {id, name, arguments}; tools is the source's tool definitions as JSON text. | |
| - outcome: "resolved" / "failed" when the source labels the run (verified, resolved, reward), "incomplete" when the | |
| source records that the run stopped with an error (for example a timeout), else "unlabeled". | |
| - n_chars, n_tokens_*: characters and tokens of a ChatML rendering (tools as one system turn; reasoning, content and | |
| tool calls of each turn), with allenai/dolma2-tokenizer-sigdig @86d32e8 and HuggingFaceTB/SmolLM3-3B, no special | |
| tokens added. | |
| - content_hash: blake2b-64 of that rendering, for deduplication inside and across sources. | |
| Filters (light; the training mix selects further): | |
| - rows with no assistant turn or that do not parse; | |
| - rows of the 12 SWE-bench repositories, also forks with the same name (matched on the repository basename); | |
| - exact duplicates of the rendering inside a source (the first one stays, in file order). | |
| Sources are read at a pinned commit. Files are downloaded and cut into work units (parquet row groups of at most | |
| SLICE_ROWS rows, after re-chunking larger ones in one streaming pass; jsonl byte ranges), converted in parallel | |
| processes, then deduplicated and written as shards of about 1.5 GB of text. | |
| Shared hosts: every process sets oom_score_adj 1000 (the kernel kills these first), new units wait while the | |
| cgroup's anonymous memory is above MEMORY_SHARE of its limit, and each downloaded file is deleted when its units end. | |
| """ | |
| import argparse | |
| import hashlib | |
| import json | |
| import os | |
| import shutil | |
| import sys | |
| import time | |
| from collections import deque | |
| from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, ThreadPoolExecutor, wait | |
| from pathlib import Path | |
| HERE = Path(__file__).resolve().parent | |
| TOKDIR = Path(os.environ.get("POOL_TOK", HERE.parent / "datasize" / "tok")) | |
| OUT = Path(os.environ["POOL_OUT"]) if "POOL_OUT" in os.environ else HERE.parents[3] / "build" / "pool_repo" | |
| TMP = Path(os.environ["POOL_TMP"]) if "POOL_TMP" in os.environ else HERE.parents[3] / "build" / "pool_tmp" | |
| REPO = "MINZIK77/midtraining-pool" | |
| CATEGORY = "trajectory" # data/CATEGORY/NAME/ and config CATEGORY-NAME (this script builds the trajectory category) | |
| SWEB = {"astropy", "django", "matplotlib", "seaborn", "flask", "requests", "xarray", "pylint", | |
| "pytest", "scikit-learn", "sphinx", "sympy"} | |
| ROLE = {"gpt": "assistant", "human": "user", "model": "assistant", "function": "tool", "observation": "tool", | |
| "ipython": "tool", "tool_response": "tool"} | |
| SLICE_ROWS = 512 # parquet work unit: one row group of at most this many rows (larger row groups are re-chunked) | |
| CHUNK_BYTES = 32 << 20 # jsonl work unit: lines that start in this many bytes | |
| TOKEN_BATCH = 32 # rows per tokenizer call (only the lengths are kept) | |
| SHARD_CHARS = 1_500_000_000 # output shard: about this much rendered text | |
| MEMORY_SHARE = 0.4 # do not start new work units while the cgroup's anonymous memory is above this share of its limit | |
| def repo_base(s): | |
| if not s: | |
| return None | |
| s = str(s).lower() | |
| if "__" in s: # owner__repo-123 / owner__repo.hash.task | |
| s = s.split("__", 1)[1] | |
| for sep in (".", "-"): | |
| head = s.split(sep)[0] | |
| if head in SWEB: | |
| return head | |
| return s.split(".")[0] | |
| return s.rstrip("/").split("/")[-1] | |
| def is_sweb(*names): | |
| for n in names: | |
| b = repo_base(n) | |
| if b and (b in SWEB or any(b.startswith(x + "-") for x in SWEB if x not in ("requests", "flask"))): | |
| return True | |
| return False | |
| def flag(v, true_values=(1, True)): | |
| return "resolved" if v in true_values else "failed" | |
| def trove_outcome(r, p): | |
| v = r.get("result") | |
| if v in (None, "None", ""): | |
| return "unlabeled" | |
| try: | |
| return "resolved" if float(v) >= 1.0 else "failed" | |
| except ValueError: | |
| return "incomplete" # AgentTimeoutError, DaytonaError, ... | |
| # name -> spec. kind pq | jsonl. msgs: field with the turns. outcome/task/repo/group: functions of (row, path). | |
| SOURCES = { | |
| "nanoswe": dict(ds="nanoswe/nanoswe-trajs-261002", kind="pq", glob="train-*.parquet", license="mit", | |
| cols=["messages", "verified", "instance_id"], msgs="messages", | |
| scaffold="not named (tools: bash, file_editor)", | |
| outcome=lambda r, p: flag(bool(r["verified"])), task=lambda r, p: r["instance_id"]), | |
| "minicoder": dict(ds="ricdomolm/mini-coder-trajs-400k", kind="pq", glob="data/*.parquet", license="mit", | |
| cols=["messages", "verified", "instance_id"], msgs="messages", scaffold="mini-swe-agent", | |
| outcome=lambda r, p: flag(bool(r["verified"])), task=lambda r, p: r["instance_id"]), | |
| "klear": dict(ds="Kwai-Klear/SWE-smith-mini_swe_agent_plus-trajectories-66k", kind="pq", glob="data/*.parquet", | |
| license="mit", cols=["messages", "instance_id"], msgs="messages", scaffold="mini-swe-agent-plus", | |
| task=lambda r, p: r["instance_id"]), | |
| "openswe": dict(ds="nvidia/Open-SWE-Traces", kind="pq", glob="data/**/*.parquet", license="cc-by-4.0", | |
| cols=["messages", "tools", "resolved", "repo", "instance_id"], msgs="messages", tools="tools", | |
| # resolved: 1 solved, 0 not solved, -1 information unavailable (card) | |
| scaffold="see group", | |
| outcome=lambda r, p: {1: "resolved", 0: "failed"}.get(r["resolved"], "unlabeled"), | |
| task=lambda r, p: r["instance_id"], | |
| repo=lambda r, p: r["repo"], group=lambda r, p: "/".join(p.split("/")[1:-1])), | |
| # filtered_reward1-* is a second copy of the reward-1 runs (its own split on the card), so it is not read. | |
| "coderforge": dict(ds="togethercomputer/CoderForge-Preview", kind="pq", | |
| glob=["trajectories/R2E_Gym-*.parquet", "trajectories/SWE_Rebench-*.parquet", | |
| "trajectories/SWE_Smith-*.parquet"], | |
| license="none stated", cols=["messages", "tools", "reward", "image"], msgs="messages", | |
| tools="tools", scaffold="single scaffold (not named on the card)", | |
| group=lambda r, p: p.split("/")[-1].split("-")[0], | |
| outcome=lambda r, p: "resolved" if (r["reward"] or 0) >= 1.0 else "failed", | |
| task=lambda r, p: (r["image"] or "").split("/")[-1] or None, | |
| repo=lambda r, p: (r["image"] or "").split("/")[-1].split(":")[0].replace("_1776_", "__") or None), | |
| "nemoswe_v1": dict(ds="nvidia/Nemotron-SWE-v1", kind="jsonl", glob="data/r2e_gym.jsonl", license="cc-by-4.0", | |
| msgs="messages", tools="tools", scaffold="openhands", repo=lambda r, p: r.get("repo")), | |
| "nemoswe_v2_oh": dict(ds="nvidia/Nemotron-SFT-SWE-v2", kind="jsonl", glob="data/swe.jsonl", | |
| license="cc-by-4.0 (+ code licenses)", msgs="messages", tools="tools", scaffold="openhands"), | |
| # exit_status is 'submit' when the agent ended with its terminating action, else an OpenHands error message. | |
| "nebius_oh": dict(ds="nebius/SWE-rebench-openhands-trajectories", kind="pq", glob="*.parquet", license="cc-by-4.0", | |
| cols=["trajectory", "tools", "resolved", "repo", "instance_id", "exit_status"], msgs="trajectory", | |
| tools="tools", scaffold="openhands", | |
| outcome=lambda r, p: "resolved" if r["resolved"] == 1 else | |
| ("failed" if r.get("exit_status") == "submit" else "incomplete"), | |
| task=lambda r, p: r["instance_id"], | |
| repo=lambda r, p: r["repo"]), | |
| "swezero": dict(ds="nvidia/SWE-Zero-openhands-trajectories", kind="pq", glob="data/*.parquet", license="cc-by-4.0", | |
| cols=["trajectory", "repo"], msgs="trajectory", scaffold="openhands", repo=lambda r, p: r["repo"]), | |
| "scaleswe": dict(ds="AweAI-Team/Scale-SWE-Distilled", kind="pq", glob="data/*.parquet", license="none stated", | |
| cols=["messages", "system"], msgs="messages", system="system", scaffold="unspecified"), | |
| "sera": dict(ds="allenai/SERA-4.6-Lite-Best-Subset", kind="jsonl", glob="*.jsonl", license="apache-2.0", | |
| msgs="messages", scaffold="unspecified", task=lambda r, p: r.get("instance_id")), | |
| "terminal": dict(ds="nvidia/Nemotron-Terminal-Corpus", kind="pq", glob="**/*.parquet", license="cc-by-4.0", | |
| cols=["conversations"], msgs="conversations", scaffold="not named", | |
| group=lambda r, p: "/".join(p.split("/")[:-1]) or None), | |
| "otagent": dict(ds="open-thoughts/OpenThoughts-Agent-SFT-100K", kind="pq", glob="data/*.parquet", | |
| license="apache-2.0", cols=["conversations"], msgs="conversations", scaffold="terminus-2"), | |
| "agenttrove": dict(ds="open-thoughts/AgentTrove", kind="pq", glob="data/*.parquet", license="apache-2.0", | |
| cols=["conversations", "result", "original_source", "trace_source"], msgs="conversations", | |
| scaffold="terminus-2 (Harbor)", outcome=trove_outcome, | |
| group=lambda r, p: "/".join(str(x) for x in (r.get("original_source"), r.get("trace_source")) if x)), | |
| "opencode": dict(ds="nvidia/Nemotron-SFT-OpenCode-v1", kind="jsonl", glob="*/data.jsonl", license="cc-by-4.0", | |
| msgs="messages", tools="tools", scaffold="opencode", group=lambda r, p: p.split("/")[-2]), | |
| } | |
| def text_of(c): | |
| if c is None: | |
| return "" | |
| if isinstance(c, str): | |
| return c | |
| if isinstance(c, list): | |
| return "".join(x.get("text", "") if isinstance(x, dict) else str(x) for x in c) | |
| if isinstance(c, dict): | |
| return c.get("text") if isinstance(c.get("text"), str) else json.dumps(c, ensure_ascii=False, default=str) | |
| return str(c) | |
| def opt(v): | |
| return None if v is None or v == "" else str(v) | |
| def norm_messages(msgs, system=None): | |
| if isinstance(msgs, str): | |
| msgs = json.loads(msgs) | |
| out = [] | |
| if system and not any(isinstance(m, dict) and (m.get("role") or m.get("from")) == "system" for m in msgs or []): | |
| out.append(dict(role="system", content=str(system), reasoning=None, tool_calls=None, tool_call_id=None, name=None)) | |
| for m in msgs or []: | |
| if not isinstance(m, dict): | |
| continue | |
| role = m.get("role") or m.get("from") or "" | |
| role = ROLE.get(role, role) | |
| content = text_of(m.get("content", m.get("value"))) | |
| for part in m.get("parts") or []: | |
| content += part.get("text", "") if isinstance(part, dict) else str(part) | |
| calls = m.get("tool_calls") | |
| if isinstance(calls, str): | |
| calls = json.loads(calls) if calls.strip() else None | |
| norm = [] | |
| for tc in calls or []: | |
| fn = tc.get("function", tc) if isinstance(tc, dict) else {} | |
| args = fn.get("arguments") | |
| norm.append({"id": tc.get("id") if isinstance(tc, dict) else None, "name": fn.get("name"), | |
| "arguments": args if isinstance(args, str) or args is None else json.dumps(args, ensure_ascii=False, default=str)}) | |
| out.append(dict(role=str(role), content=content, reasoning=opt(m.get("reasoning_content") or m.get("reasoning")), | |
| tool_calls=json.dumps(norm, ensure_ascii=False) if norm else None, | |
| tool_call_id=opt(m.get("tool_call_id")), name=opt(m.get("name")))) | |
| return out | |
| def norm_tools(t): | |
| if t is None: | |
| return None | |
| if isinstance(t, str): | |
| return t or None | |
| if isinstance(t, (list, tuple)): | |
| if not t: | |
| return None | |
| if all(isinstance(x, str) for x in t): | |
| try: | |
| return json.dumps([json.loads(x) for x in t], ensure_ascii=False) | |
| except ValueError: | |
| return "\n".join(t) | |
| return json.dumps(t, ensure_ascii=False, default=str) | |
| def render(messages, tools): | |
| s = [f"<|im_start|>system\n# Tools\n{tools}<|im_end|>\n"] if tools else [] | |
| for m in messages: | |
| parts = [p for p in (m["reasoning"], m["content"]) if p] | |
| for c in json.loads(m["tool_calls"]) if m["tool_calls"] else []: | |
| parts.append(json.dumps({"name": c["name"], "arguments": c["arguments"]}, ensure_ascii=False)) | |
| s.append(f"<|im_start|>{m['role']}\n" + "\n".join(parts) + "<|im_end|>\n") | |
| return "".join(s) | |
| def schema(): | |
| import pyarrow as pa | |
| msg = pa.struct([("role", pa.string()), ("content", pa.string()), ("reasoning", pa.string()), | |
| ("tool_calls", pa.string()), ("tool_call_id", pa.string()), ("name", pa.string())]) | |
| return pa.schema([("id", pa.string()), ("source", pa.string()), ("task_id", pa.string()), ("repo", pa.string()), | |
| ("scaffold", pa.string()), ("outcome", pa.string()), ("group", pa.string()), | |
| ("messages", pa.list_(msg)), ("tools", pa.string()), ("n_messages", pa.int32()), | |
| ("n_chars", pa.int64()), ("n_tokens_sigdig", pa.int32()), ("n_tokens_smollm3", pa.int32()), | |
| ("content_hash", pa.string())]) | |
| _TOK = None | |
| def tokenizers(): | |
| global _TOK | |
| if _TOK is None: | |
| from tokenizers import Tokenizer | |
| _TOK = Tokenizer.from_file(str(TOKDIR / "sigdig.json")), Tokenizer.from_file(str(TOKDIR / "smollm3.json")) | |
| return _TOK | |
| def revision(ds): | |
| from huggingface_hub import HfApi | |
| return HfApi().dataset_info(ds).sha | |
| def list_files(spec, rev): | |
| from huggingface_hub import HfFileSystem | |
| base = f"datasets/{spec['ds']}@{rev}" | |
| globs = spec["glob"] if isinstance(spec["glob"], list) else [spec["glob"]] | |
| return sorted({p[len(base) + 1:] for g in globs for p in HfFileSystem().glob(f"{base}/{g}")}) | |
| def convert(name, spec, rel, key, r): | |
| """One source row -> one pool row (without the rendering columns), or the drop reason.""" | |
| try: | |
| messages = norm_messages(r[spec["msgs"]], r.get(spec["system"]) if spec.get("system") else None) | |
| tools = norm_tools(r.get(spec["tools"])) if spec.get("tools") else None | |
| except (ValueError, TypeError, AttributeError, KeyError): | |
| return "parse_error" | |
| if not any(m["role"] == "assistant" for m in messages): | |
| return "no_assistant" | |
| task = opt(spec["task"](r, rel)) if spec.get("task") else None | |
| repo = opt(spec["repo"](r, rel)) if spec.get("repo") else None | |
| if is_sweb(repo, task): | |
| return "swebench" | |
| group = opt(spec["group"](r, rel)) if spec.get("group") else None | |
| sep = "@" if spec["kind"] == "jsonl" else "/" | |
| return dict(id=f"{name}/{rel}{sep}{key}", source=name, task_id=task, repo=repo, | |
| scaffold=group.split("/")[0] if spec["scaffold"] == "see group" and group else spec["scaffold"], | |
| outcome=spec["outcome"](r, rel) if spec.get("outcome") else "unlabeled", group=group, | |
| messages=messages, tools=tools, n_messages=len(messages)) | |
| # ---------------------------------------------------------------- shared-host guards | |
| def low_priority(): | |
| """Ask the kernel to kill these processes first if memory runs out (other jobs share the host).""" | |
| try: | |
| with open("/proc/self/oom_score_adj", "w") as f: | |
| f.write("1000") | |
| except OSError: | |
| pass | |
| def memory_ok(): | |
| """False while the cgroup's anonymous memory is above MEMORY_SHARE of its limit (cgroup v2; else True).""" | |
| try: | |
| limit = open("/sys/fs/cgroup/memory.max").read().strip() | |
| if limit == "max": | |
| limit = os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") | |
| anon = next(int(line.split()[1]) for line in open("/sys/fs/cgroup/memory.stat") if line.startswith("anon ")) | |
| return anon < MEMORY_SHARE * int(limit) | |
| except (OSError, StopIteration, ValueError): | |
| return True | |
| # ---------------------------------------------------------------- work units | |
| def fetch(spec, rev, rel): | |
| from huggingface_hub import hf_hub_download | |
| for attempt in range(5): | |
| try: | |
| return hf_hub_download(spec["ds"], rel, repo_type="dataset", revision=rev, | |
| local_dir=str(TMP / spec["ds"].replace("/", "__"))) | |
| except Exception as error: # network or Hub errors | |
| if attempt == 4: | |
| raise | |
| print(f"download {rel} failed ({type(error).__name__}), retry", flush=True) | |
| time.sleep(30 * (attempt + 1)) | |
| def units_of(spec, path): | |
| """Work units of a file: ("pq", row group, first row) or ("jsonl", start, end); None if it needs re-chunking.""" | |
| if spec["kind"] == "pq": | |
| import pyarrow.parquet as pq | |
| meta = pq.ParquetFile(path).metadata | |
| sizes = [meta.row_group(rg).num_rows for rg in range(meta.num_row_groups)] | |
| if any(n > SLICE_ROWS for n in sizes): | |
| return None | |
| bases = [sum(sizes[:rg]) for rg in range(len(sizes))] | |
| return [("pq", rg, base) for rg, base in enumerate(bases) if sizes[rg]] | |
| size = os.path.getsize(path) | |
| return [("jsonl", s, min(size, s + CHUNK_BYTES)) for s in range(0, size, CHUNK_BYTES)] | |
| def rechunk(name, path): | |
| """Stream a parquet file (only the needed columns) into files of SLICE_ROWS rows, one row group each. | |
| Returns [(chunk path, first row in the source file)]. Memory stays at a few batches.""" | |
| import pyarrow as pa | |
| import pyarrow.parquet as pq | |
| low_priority() | |
| spec = SOURCES[name] | |
| out = Path(f"{path}.chunks") | |
| shutil.rmtree(out, ignore_errors=True) | |
| out.mkdir() | |
| pf = pq.ParquetFile(path, pre_buffer=False, buffer_size=8 << 20) | |
| chunks, buf, rows, first = [], [], 0, 0 | |
| for batch in pf.iter_batches(batch_size=64, columns=spec["cols"]): | |
| buf.append(batch) | |
| rows += batch.num_rows | |
| if rows >= SLICE_ROWS: | |
| table = pa.Table.from_batches(buf) | |
| head, rest = table.slice(0, SLICE_ROWS), table.slice(SLICE_ROWS) | |
| p = out / f"{len(chunks):06d}.parquet" | |
| pq.write_table(head, p, compression="lz4", row_group_size=SLICE_ROWS) | |
| chunks.append((str(p), first)) | |
| first += SLICE_ROWS | |
| buf, rows = (rest.to_batches() if rest.num_rows else []), rest.num_rows | |
| if rows: | |
| p = out / f"{len(chunks):06d}.parquet" | |
| pq.write_table(pa.Table.from_batches(buf), p, compression="lz4", row_group_size=SLICE_ROWS) | |
| chunks.append((str(p), first)) | |
| os.remove(path) | |
| return chunks | |
| def read_unit(spec, path, unit): | |
| """(key, row) pairs of one unit. A jsonl line belongs to the unit in which its first byte lies.""" | |
| if unit[0] == "pq": | |
| import pyarrow.parquet as pq | |
| _, rg, base = unit | |
| cols = spec["cols"] if not path.endswith(".chunks") and ".chunks/" not in path else None | |
| table = pq.ParquetFile(path).read_row_group(rg, columns=cols) | |
| for i, r in enumerate(table.to_pylist()): | |
| yield base + i, r | |
| return | |
| _, start, end = unit | |
| with open(path, "rb") as f: | |
| if start: | |
| f.seek(start - 1) | |
| f.readline() # skip the line that started before this unit | |
| while True: | |
| pos = f.tell() | |
| if pos >= end: | |
| return | |
| line = f.readline() | |
| if not line: | |
| return | |
| if line.strip(): | |
| yield pos, json.loads(line) | |
| def run_unit(name, rel, path, unit, order): | |
| """Convert one unit into OUT/parts/NAME/ORDER.parquet. ORDER sorts the parts in file order.""" | |
| import pyarrow as pa | |
| import pyarrow.parquet as pq | |
| low_priority() | |
| spec = SOURCES[name] | |
| sig, smol = tokenizers() | |
| counts = dict(rows=0, kept=0, parse_error=0, no_assistant=0, swebench=0) | |
| rows = [] | |
| for key, r in read_unit(spec, path, unit): | |
| counts["rows"] += 1 | |
| row = convert(name, spec, rel, key, r) | |
| if isinstance(row, str): | |
| counts[row] += 1 | |
| continue | |
| rows.append(row) | |
| counts["kept"] = len(rows) | |
| if rows: | |
| for i in range(0, len(rows), TOKEN_BATCH): | |
| batch = rows[i:i + TOKEN_BATCH] | |
| texts = [render(x["messages"], x["tools"]) for x in batch] | |
| a = [len(e.ids) for e in sig.encode_batch_fast(texts, add_special_tokens=False)] | |
| b = [len(e.ids) for e in smol.encode_batch_fast(texts, add_special_tokens=False)] | |
| for x, t, na, nb in zip(batch, texts, a, b, strict=True): | |
| x.update(n_chars=len(t), n_tokens_sigdig=na, n_tokens_smollm3=nb, | |
| content_hash=hashlib.blake2b(t.encode("utf-8"), digest_size=8).hexdigest()) | |
| out = OUT / "parts" / name | |
| out.mkdir(parents=True, exist_ok=True) | |
| pq.write_table(pa.Table.from_pylist(rows, schema=schema()), out / f"{order:012d}.parquet", | |
| compression="zstd", compression_level=6, row_group_size=256) | |
| return counts | |
| def compact(name, shard, parts, keeps): | |
| """Write the kept rows of consecutive parts as OUT/data/NAME/train-SHARD.parquet. Returns sums of the kept rows.""" | |
| import pyarrow as pa | |
| import pyarrow.compute as pc | |
| import pyarrow.parquet as pq | |
| low_priority() | |
| out = OUT / "data" / CATEGORY / name / f"train-{shard:05d}.parquet" | |
| sums = dict(rows=0, chars=0, tokens_sigdig=0, tokens_smollm3=0, outcomes={}) | |
| with pq.ParquetWriter(out, schema(), compression="zstd", compression_level=6) as writer: | |
| for part, keep in zip(parts, keeps, strict=True): | |
| table = pq.read_table(part).filter(pa.array(keep)) | |
| writer.write_table(table, row_group_size=256) | |
| sums["rows"] += table.num_rows | |
| sums["chars"] += pc.sum(table["n_chars"]).as_py() or 0 | |
| sums["tokens_sigdig"] += pc.sum(table["n_tokens_sigdig"]).as_py() or 0 | |
| sums["tokens_smollm3"] += pc.sum(table["n_tokens_smollm3"]).as_py() or 0 | |
| for k, v in zip(*pc.value_counts(table["outcome"]).flatten(), strict=True): | |
| sums["outcomes"][k.as_py()] = sums["outcomes"].get(k.as_py(), 0) + v.as_py() | |
| return sums | |
| def plan_shards(name): | |
| """Keep masks (first copy of each content_hash in part order) and the parts of each shard.""" | |
| import pyarrow.parquet as pq | |
| parts = sorted((OUT / "parts" / name).glob("*.parquet")) | |
| seen, shards, cur, size, dropped = set(), [], [], 0, 0 | |
| for part in parts: | |
| t = pq.read_table(part, columns=["content_hash", "n_chars"]) | |
| keep = [] | |
| for h in t["content_hash"].to_pylist(): | |
| keep.append(h not in seen) | |
| seen.add(h) | |
| dropped += keep.count(False) | |
| cur.append((part, keep)) | |
| size += sum(c for c, k in zip(t["n_chars"].to_pylist(), keep, strict=True) if k) | |
| if size >= SHARD_CHARS: | |
| shards.append(cur) | |
| cur, size = [], 0 | |
| if cur: | |
| shards.append(cur) | |
| return shards, dropped | |
| # ---------------------------------------------------------------- driver | |
| def build(names, workers, do_upload): | |
| """Download, convert, deduplicate, shard (and upload) every source in `names`, all through one process pool. | |
| At most `workers` process tasks run at a time, and no new unit starts while memory_ok() is False.""" | |
| import multiprocessing | |
| low_priority() | |
| os.environ["RAYON_NUM_THREADS"] = "1" # parallelism comes from the processes | |
| TMP.mkdir(parents=True, exist_ok=True) | |
| t0 = time.time() | |
| # spawn, not fork: the driver also runs download and upload threads | |
| procs = ProcessPoolExecutor(max_workers=workers, mp_context=multiprocessing.get_context("spawn"), | |
| initializer=low_priority) | |
| downloads = ThreadPoolExecutor(max_workers=16) | |
| uploads = ThreadPoolExecutor(max_workers=1) | |
| state, pending, ready, file_left = {}, {}, deque(), {} | |
| busy = 0 # process tasks submitted and not done | |
| for name in names: | |
| spec = SOURCES[name] | |
| rev = revision(spec["ds"]) | |
| files = list_files(spec, rev) | |
| for d in (OUT / "parts" / name, OUT / "data" / CATEGORY / name): | |
| shutil.rmtree(d, ignore_errors=True) | |
| (OUT / "data" / CATEGORY / name).mkdir(parents=True, exist_ok=True) | |
| state[name] = dict(spec=spec, rev=rev, files=files, open=len(files), units=0, done_units=0, | |
| counts=dict(rows=0, kept=0, parse_error=0, no_assistant=0, swebench=0), shards=0, sums=[]) | |
| print(f"[{name}] {spec['ds']}@{rev[:10]}: {len(files)} files", flush=True) | |
| for i, rel in enumerate(files): | |
| pending[downloads.submit(fetch, spec, rev, rel)] = ("download", name, (i, rel)) | |
| def add_units(name, i, rel, path, units, base_order=0): | |
| file_left[path] = len(units) | |
| state[name]["units"] += len(units) | |
| for j, unit in enumerate(units): | |
| ready.append((name, rel, path, unit, i * 1_000_000 + base_order + j)) | |
| if not units: | |
| os.remove(path) | |
| def finish(name): | |
| st = state[name] | |
| tot = {k: sum(s[k] for s in st["sums"]) for k in ("rows", "chars", "tokens_sigdig", "tokens_smollm3")} | |
| outcomes = {} | |
| for s in st["sums"]: | |
| for k, v in s["outcomes"].items(): | |
| outcomes[k] = outcomes.get(k, 0) + v | |
| stats = dict(name=name, dataset=st["spec"]["ds"], revision=st["rev"], license=st["spec"]["license"], | |
| scaffold=st["spec"]["scaffold"], files=len(st["files"]), built=time.strftime("%Y-%m-%d"), | |
| rows=st["counts"]["rows"], kept=tot["rows"], parse_error=st["counts"]["parse_error"], | |
| no_assistant=st["counts"]["no_assistant"], swebench=st["counts"]["swebench"], | |
| duplicate=st["dropped"], outcomes=outcomes, chars=tot["chars"], | |
| tokens_sigdig=tot["tokens_sigdig"], tokens_smollm3=tot["tokens_smollm3"], shards=st["shards"]) | |
| (OUT / "stats" / CATEGORY).mkdir(parents=True, exist_ok=True) | |
| (OUT / "stats" / CATEGORY / f"{name}.json").write_text(json.dumps(stats, indent=1)) | |
| shutil.rmtree(OUT / "parts" / name, ignore_errors=True) | |
| shutil.rmtree(TMP / st["spec"]["ds"].replace("/", "__"), ignore_errors=True) | |
| print(f"[{name}] done in {time.time() - t0:.0f}s: {json.dumps(stats)}", flush=True) | |
| if do_upload: | |
| pending[uploads.submit(upload, [name])] = ("upload", name, None) | |
| waited = 0.0 | |
| while pending or ready: | |
| while ready and busy < workers: | |
| if not memory_ok(): | |
| break | |
| name, rel, path, unit, order = ready.popleft() | |
| pending[procs.submit(run_unit, name, rel, path, unit, order)] = ("unit", name, path) | |
| busy += 1 | |
| if not pending: # only units left, held back by memory_ok() | |
| time.sleep(5) | |
| waited += 5 | |
| continue | |
| done, _ = wait(list(pending), timeout=10, return_when=FIRST_COMPLETED) | |
| if not done and ready and not memory_ok(): | |
| waited += 10 | |
| for fut in done: | |
| kind, name, extra = pending.pop(fut) | |
| st = state[name] | |
| result = fut.result() # an error stops the build | |
| if kind == "download": | |
| i, rel = extra | |
| units = units_of(st["spec"], result) | |
| if units is None: | |
| pending[procs.submit(rechunk, name, result)] = ("rechunk", name, (i, rel)) | |
| busy += 1 | |
| else: | |
| st["open"] -= 1 | |
| add_units(name, i, rel, result, units) | |
| elif kind == "rechunk": | |
| busy -= 1 | |
| i, rel = extra | |
| st["open"] -= 1 | |
| for k, (chunk, first) in enumerate(result): | |
| add_units(name, i, rel, chunk, [("pq", 0, first)], base_order=k * 1000) | |
| elif kind == "unit": | |
| busy -= 1 | |
| st["done_units"] += 1 | |
| for k in st["counts"]: | |
| st["counts"][k] += result[k] | |
| file_left[extra] -= 1 | |
| if file_left[extra] == 0: | |
| os.remove(extra) | |
| del file_left[extra] | |
| if st["done_units"] % 500 == 0: | |
| print(f"[{name}] {st['done_units']}/{st['units']} units ({st['open']} files open), " | |
| f"{st['counts']['kept']} rows, {time.time() - t0:.0f}s, memory waits {waited:.0f}s", flush=True) | |
| elif kind == "shard": | |
| busy -= 1 | |
| st["sums"].append(result) | |
| if len(st["sums"]) == st["shards"]: | |
| finish(name) | |
| elif kind == "upload": | |
| print(f"[{name}] uploaded", flush=True) | |
| if kind in ("download", "rechunk", "unit") and st["open"] == 0 and st["done_units"] == st["units"] \ | |
| and "dropped" not in st: | |
| shards, st["dropped"] = plan_shards(name) | |
| st["shards"] = len(shards) | |
| print(f"[{name}] {st['units']} units converted; {st['dropped']} duplicates; {len(shards)} shards", | |
| flush=True) | |
| if not shards: | |
| finish(name) | |
| for k, shard in enumerate(shards): | |
| parts, keeps = zip(*shard, strict=True) | |
| pending[procs.submit(compact, name, k, list(parts), list(keeps))] = ("shard", name, None) | |
| busy += 1 | |
| procs.shutdown() | |
| downloads.shutdown() | |
| uploads.shutdown() | |
| # ---------------------------------------------------------------- probe, card, upload | |
| def probe(name, rows): | |
| """Parse a few rows of the middle file by range requests and print one normalized row.""" | |
| import pyarrow.parquet as pq | |
| from huggingface_hub import HfFileSystem | |
| spec = SOURCES[name] | |
| rev = revision(spec["ds"]) | |
| files = list_files(spec, rev) | |
| rel = files[len(files) // 2] | |
| print(f"[{name}] {spec['ds']}@{rev[:10]} {len(files)} files; probing {rel}") | |
| path = f"datasets/{spec['ds']}@{rev}/{rel}" | |
| raw = [] | |
| if spec["kind"] == "pq": | |
| with HfFileSystem().open(path, "rb", block_size=32 << 20) as f: | |
| for batch in pq.ParquetFile(f).iter_batches(batch_size=rows, columns=spec["cols"]): | |
| raw = batch.to_pylist()[:rows] | |
| break | |
| else: | |
| with HfFileSystem().open(path, "r", encoding="utf-8", block_size=8 << 20) as f: | |
| for i, line in enumerate(f): | |
| if i >= rows: | |
| break | |
| if line.strip(): | |
| raw.append(json.loads(line)) | |
| kept, reasons, outcomes = [], {}, {} | |
| for i, r in enumerate(raw): | |
| row = convert(name, spec, rel, i, r) | |
| if isinstance(row, str): | |
| reasons[row] = reasons.get(row, 0) + 1 | |
| continue | |
| kept.append(row) | |
| outcomes[row["outcome"]] = outcomes.get(row["outcome"], 0) + 1 | |
| if not kept: | |
| print("no row kept", reasons) | |
| return | |
| sig, _ = tokenizers() | |
| toks = [len(e.ids) for e in sig.encode_batch_fast([render(x["messages"], x["tools"]) for x in kept], | |
| add_special_tokens=False)] | |
| print(f"kept {len(kept)} dropped {reasons} outcomes {outcomes}; tokens median {sorted(toks)[len(toks) // 2]}") | |
| def upload(names): | |
| """Upload the built configs (data, stats) and this script. README.md and LICENSE.md are written by make_card.py | |
| from the cross-checked source facts, so this function does not touch them.""" | |
| import fcntl | |
| from huggingface_hub import HfApi | |
| api = HfApi() | |
| names = names or sorted(p.stem for p in (OUT / "stats" / CATEGORY).glob("*.json")) | |
| with open(OUT / ".upload.lock", "w") as lock: | |
| fcntl.flock(lock, fcntl.LOCK_EX) | |
| api.create_repo(REPO, repo_type="dataset", private=False, exist_ok=True) | |
| (OUT / "scripts").mkdir(exist_ok=True) | |
| shutil.copy(__file__, OUT / "scripts" / "build_pool.py") | |
| for attempt in range(3): # one commit per call; the Hub skips content it already has on a retry | |
| try: | |
| api.upload_folder(repo_id=REPO, repo_type="dataset", folder_path=str(OUT), | |
| commit_message=f"Add {CATEGORY}: {', '.join(names)}", | |
| allow_patterns=["scripts/build_pool.py", *[f"stats/{CATEGORY}/{n}.json" for n in names], | |
| *[f"data/{CATEGORY}/{n}/*" for n in names]], | |
| delete_patterns=[f"data/{CATEGORY}/{n}/*" for n in names]) | |
| return | |
| except Exception as error: # network or Hub errors | |
| print(f"upload attempt {attempt + 1} failed: {type(error).__name__}: {error}", flush=True) | |
| time.sleep(60) | |
| raise SystemExit(f"upload of {names} failed") | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("cmd", choices=["probe", "build", "upload"]) | |
| ap.add_argument("names", nargs="*") | |
| ap.add_argument("--rows", type=int, default=40) | |
| ap.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 4) - 2)) | |
| ap.add_argument("--upload", action="store_true", help="build: upload each source after it is built") | |
| a = ap.parse_args() | |
| for n in a.names: | |
| if n not in SOURCES: | |
| sys.exit(f"unknown source {n}; known: {sorted(SOURCES)}") | |
| if a.cmd == "probe": | |
| for n in a.names or sorted(SOURCES): | |
| probe(n, a.rows) | |
| elif a.cmd == "build": | |
| build(a.names or sorted(SOURCES), a.workers, a.upload) | |
| else: | |
| upload(a.names) | |
| if __name__ == "__main__": | |
| main() | |