midtraining-pool / scripts /build_pool.py
MINZIK77's picture
Rewrite the card: categories, source facts, labels
78b2e7f verified
Raw History Blame Contribute Delete
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()