#!/usr/bin/env python3 """Build the public KernelZero CUDA SFT dataset from the exact training files.""" from __future__ import annotations import argparse import hashlib import json import math import re import statistics from pathlib import Path import pyarrow as pa import pyarrow.parquet as pq STAGES = [ { "name": "stage1", "sft": "resources/modules/turn1/cudallm_24k_sft_v1.json", "sources": [ "resources/modules/turn1/cudallm_modules_distilled_0_40000_checked_passed.jsonl", "resources/modules/turn1/cudallm_modules_distilled_40000_90000_checked_passed.jsonl", ], }, { "name": "stage2", "sft": "resources/modules/turn3/cudallm_19k_sft_t2t3.json", "sources": [ "resources/modules/turn2/cudallm_modules_distilled_0_40000_2_checked_passed.jsonl", "resources/modules/turn2/cudallm_modules_distilled_40000_90000_2_checked_passed.jsonl", "resources/modules/turn3/cudallm_modules_distilled_0_40000_3_distilled_checked_passed.jsonl", "resources/modules/turn3/cudallm_modules_distilled_40000_90000_3_distilled_checked_passed.jsonl", ], }, ] def read_jsonl(path: Path): with path.open(encoding="utf-8") as handle: for line_no, line in enumerate(handle, 1): if line.strip(): try: yield json.loads(line) except json.JSONDecodeError as exc: raise ValueError(f"Invalid JSON in {path}:{line_no}") from exc def extract_cuda_code(answer: str) -> tuple[str, bool]: answer = answer.strip() match = re.fullmatch(r"```(?:python)?\s*\n?(.*?)\n?```", answer, flags=re.DOTALL) if match: return match.group(1).strip(), True return answer, False def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--root", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) parser.add_argument("--num-shards", type=int, default=8) args = parser.parse_args() root = args.root.resolve() output = args.output.resolve() data_dir = output / "data" data_dir.mkdir(parents=True, exist_ok=True) records: list[dict] = [] stage_counts: dict[str, int] = {} output_mismatches: list[dict] = [] missing_speedup: list[dict] = [] unfenced_answers: list[dict] = [] for stage in STAGES: source_by_index: dict[int, dict] = {} for relative in stage["sources"]: source_path = root / relative for item in read_jsonl(source_path): index = int(item["index"]) if index in source_by_index: raise ValueError(f"Duplicate source index in {stage['name']}: {index}") source_by_index[index] = item with (root / stage["sft"]).open(encoding="utf-8") as handle: sft_rows = json.load(handle) stage_counts[stage["name"]] = len(sft_rows) if len(sft_rows) != len(source_by_index): raise ValueError( f"Count mismatch for {stage['name']}: " f"SFT={len(sft_rows)} source={len(source_by_index)}" ) for sft in sft_rows: index = int(sft["index"]) source = source_by_index.get(index) if source is None: raise ValueError(f"Missing source for {stage['name']} index={index}") response = source.get("response") or {} reasoning = str(response.get("reasoning", "")).strip() answer = str(response.get("answer", "")).strip() reconstructed_output = f"{reasoning}\n{answer}" if reconstructed_output != sft["output"]: output_mismatches.append({"stage": stage["name"], "index": index}) result = source.get("result") or {} message = result.get("msg") or {} speedup = message.get("speedup") if isinstance(message, dict) else None if not isinstance(speedup, (int, float)) or not math.isfinite(float(speedup)): missing_speedup.append({"stage": stage["name"], "index": index}) continue cuda_code, fenced = extract_cuda_code(answer) if not fenced: unfenced_answers.append({"stage": stage["name"], "index": index}) operators = source.get("ops", "[]") if isinstance(operators, str): try: operators = json.loads(operators) except json.JSONDecodeError: operators = [operators] operators = [str(op) for op in operators] records.append( { "input": sft["instruction"], "output": sft["output"], "torch_module": str(source["module"]), "cuda_code": cuda_code, "speedup": float(speedup), "operators": operators, "source_stage": stage["name"], "source_index": index, } ) if output_mismatches: raise ValueError(f"Output mismatches: {len(output_mismatches)}") if missing_speedup: raise ValueError(f"Missing or invalid speedups: {len(missing_speedup)}") if len(records) != 43_302: raise ValueError(f"Expected 43,302 records, found {len(records)}") identities = {(row["source_stage"], row["source_index"]) for row in records} if len(identities) != len(records): raise ValueError("Duplicate source identities") full_hashes = { hashlib.sha256( (row["input"] + "\0" + row["output"] + "\0" + row["torch_module"]).encode() ).hexdigest() for row in records } if len(full_hashes) != len(records): raise ValueError("Duplicate training records") schema = pa.schema( [ ("input", pa.string()), ("output", pa.string()), ("torch_module", pa.string()), ("cuda_code", pa.string()), ("speedup", pa.float64()), ("operators", pa.list_(pa.string())), ("source_stage", pa.string()), ("source_index", pa.int64()), ] ) shard_size = math.ceil(len(records) / args.num_shards) shard_paths: list[Path] = [] for shard_id in range(args.num_shards): start = shard_id * shard_size end = min(len(records), start + shard_size) if start >= end: break table = pa.Table.from_pylist(records[start:end], schema=schema) path = data_dir / f"train-{shard_id:05d}-of-{args.num_shards:05d}.parquet" pq.write_table(table, path, compression="zstd", compression_level=9) shard_paths.append(path) speedups = [row["speedup"] for row in records] report = { "record_count": len(records), "stage_counts": stage_counts, "unique_source_identities": len(identities), "unique_training_records": len(full_hashes), "output_mismatches": len(output_mismatches), "missing_speedup": len(missing_speedup), "unfenced_answers": len(unfenced_answers), "empty_fields": { field: sum(not row[field] for row in records) for field in ("input", "output", "torch_module", "cuda_code") }, "speedup": { "min": min(speedups), "max": max(speedups), "mean": statistics.fmean(speedups), "median": statistics.median(speedups), }, "shards": [ {"path": str(path.relative_to(output)), "bytes": path.stat().st_size, "sha256": sha256(path)} for path in shard_paths ], } (output / "validation_report.json").write_text( json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" ) print(json.dumps(report, indent=2, ensure_ascii=False)) if __name__ == "__main__": main()