| """Command-line entry points for generating and auditing BGD-SFT artifacts.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import sys |
| from collections import Counter |
| from concurrent.futures import ProcessPoolExecutor, as_completed |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
| from .audit import StatsAccumulator, build_manifest, build_report |
| from .generation import GenerationPlan, generate_record |
| from .io import ( |
| ShardResult, |
| iter_jsonl_gz, |
| sha256_file, |
| write_json_atomic, |
| write_jsonl_gz_atomic, |
| ) |
| from .serializers import build_messages |
| from .validation import validate_record |
|
|
|
|
| DEFAULT_CONFIG = Path(__file__).resolve().parents[2] / "configs" / "selected_sft_1m.json" |
|
|
|
|
| @dataclass |
| class WorkerResult: |
| shard: ShardResult |
| stats: StatsAccumulator |
| group_splits: dict[str, str] |
| invalid_examples: list[dict[str, Any]] |
|
|
|
|
| def _load_config(path: str | Path) -> dict[str, Any]: |
| config_path = Path(path) |
| config = json.loads(config_path.read_text(encoding="utf-8")) |
| if not isinstance(config, dict): |
| raise ValueError("config must be a JSON object") |
| GenerationPlan(config) |
| return config |
|
|
|
|
| def _config_digest(config: dict[str, Any]) -> str: |
| payload = json.dumps(config, ensure_ascii=False, sort_keys=True, separators=(",", ":")) |
| return hashlib.sha256(payload.encode("utf-8")).hexdigest() |
|
|
|
|
| def _record_stream( |
| config: dict[str, Any], |
| start: int, |
| end: int, |
| stats: StatsAccumulator, |
| group_splits: dict[str, str], |
| ) -> Iterable[dict[str, Any]]: |
| plan = GenerationPlan(config) |
| for index in range(start, end): |
| record = generate_record(config, plan, index) |
| errors = validate_record(record) |
| if errors: |
| raise ValueError( |
| f"generated invalid record {record.get('record_id')}: " + "; ".join(errors) |
| ) |
| source_group = record["source_group"] |
| split = record["split"] |
| previous = group_splits.setdefault(source_group, split) |
| if previous != split: |
| raise ValueError(f"source group split leakage: {source_group}: {previous} vs {split}") |
| stats.ingest(record) |
| yield record |
|
|
|
|
| def _generate_shard( |
| config: dict[str, Any], |
| output_path: str, |
| start: int, |
| end: int, |
| compresslevel: int, |
| ) -> WorkerResult: |
| stats = StatsAccumulator() |
| group_splits: dict[str, str] = {} |
| shard = write_jsonl_gz_atomic( |
| output_path, |
| _record_stream(config, start, end, stats, group_splits), |
| compresslevel=compresslevel, |
| ) |
| if shard.records != end - start: |
| raise RuntimeError(f"short shard {output_path}: {shard.records} != {end - start}") |
| return WorkerResult(shard=shard, stats=stats, group_splits=group_splits, invalid_examples=[]) |
|
|
|
|
| def _audit_shard(expected: dict[str, Any]) -> WorkerResult: |
| path = Path(expected["path"]) |
| actual_hash = sha256_file(path) |
| invalid_examples: list[dict[str, Any]] = [] |
| stats = StatsAccumulator() |
| group_splits: dict[str, str] = {} |
| records = 0 |
| for record in iter_jsonl_gz(path): |
| records += 1 |
| errors = validate_record(record) |
| if errors and len(invalid_examples) < 20: |
| invalid_examples.append({"record_id": record.get("record_id"), "errors": errors}) |
| stats.ingest(record) |
| source_group = record.get("source_group") |
| split = record.get("split") |
| if isinstance(source_group, str) and isinstance(split, str): |
| previous = group_splits.setdefault(source_group, split) |
| if previous != split and len(invalid_examples) < 20: |
| invalid_examples.append( |
| { |
| "record_id": record.get("record_id"), |
| "errors": [f"source group split leakage: {source_group}: {previous} vs {split}"], |
| } |
| ) |
| if actual_hash != expected["sha256"]: |
| invalid_examples.append( |
| {"record_id": None, "errors": [f"checksum mismatch for {path}"]} |
| ) |
| if records != int(expected["records"]): |
| invalid_examples.append( |
| { |
| "record_id": None, |
| "errors": [f"record count mismatch for {path}: {records} != {expected['records']}"], |
| } |
| ) |
| shard = ShardResult( |
| path=path, |
| records=records, |
| sha256=actual_hash, |
| compressed_bytes=path.stat().st_size, |
| uncompressed_bytes=int(expected.get("uncompressed_bytes", 0)), |
| ) |
| return WorkerResult( |
| shard=shard, |
| stats=stats, |
| group_splits=group_splits, |
| invalid_examples=invalid_examples, |
| ) |
|
|
|
|
| def _merge_worker_results(results: list[WorkerResult]) -> tuple[StatsAccumulator, int, list[dict[str, Any]]]: |
| stats = StatsAccumulator() |
| all_group_splits: dict[str, str] = {} |
| split_conflicts = 0 |
| invalid_examples: list[dict[str, Any]] = [] |
| for result in results: |
| stats.merge(result.stats) |
| for source_group, split in result.group_splits.items(): |
| previous = all_group_splits.setdefault(source_group, split) |
| if previous != split: |
| split_conflicts += 1 |
| if len(invalid_examples) < 20: |
| invalid_examples.append( |
| { |
| "record_id": None, |
| "errors": [ |
| f"cross-shard source group leakage: {source_group}: {previous} vs {split}" |
| ], |
| } |
| ) |
| for example in result.invalid_examples: |
| if len(invalid_examples) < 20: |
| invalid_examples.append(example) |
| return stats, split_conflicts, invalid_examples |
|
|
|
|
| def _expected_counts(percent: dict[str, int], total: int) -> dict[str, int]: |
| return {key: total * value // 100 for key, value in percent.items()} |
|
|
|
|
| def _promotion_gates( |
| config: dict[str, Any], |
| stats: StatsAccumulator, |
| *, |
| requested_records: int, |
| split_conflicts: int, |
| invalid_examples: list[dict[str, Any]], |
| ) -> dict[str, Any]: |
| observed = stats.to_dict() |
| full_run = requested_records == int(config["total_records"]) |
| gates: dict[str, bool | None] = { |
| "exact_requested_record_count": observed["total_records"] == requested_records, |
| "all_records_primary_zh_tw": observed["primary_zh_tw_records"] == requested_records, |
| "no_unannotated_simplified_only_hits": observed[ |
| "unannotated_simplified_only_hit_records" |
| ] |
| == 0, |
| "record_ids_unique": observed["duplicate_record_id_occurrences"] == 0, |
| "evidence_references_resolve": observed["evidence_reference_missing"] == 0, |
| "source_groups_split_locked": split_conflicts == 0, |
| "all_records_semantically_valid": not invalid_examples, |
| "exact_split_distribution": None, |
| "exact_primitive_distribution": None, |
| "exact_mixture_distribution": None, |
| "exact_serializer_distribution": None, |
| "exact_long_context_distribution": None, |
| } |
| if full_run: |
| gates["exact_split_distribution"] = observed["split"] == _expected_counts( |
| config["split_percent"], requested_records |
| ) |
| gates["exact_primitive_distribution"] = observed["primitive"] == _expected_counts( |
| config["primitive_percent"], requested_records |
| ) |
| gates["exact_mixture_distribution"] = observed["mixture_category"] == _expected_counts( |
| config["mixture_percent"], requested_records |
| ) |
| gates["exact_serializer_distribution"] = observed["serializer"] == _expected_counts( |
| config["serializer_percent"], requested_records |
| ) |
| long_total = int(config["long_context_records"]) |
| long_expected = _expected_counts(config["long_context_bucket_percent"], long_total) |
| overall_expected = dict(long_expected) |
| overall_expected["0.5K-4K"] += requested_records - long_total |
| gates["exact_long_context_distribution"] = observed["context_bucket"] == overall_expected |
| evaluated = [value for value in gates.values() if value is not None] |
| return { |
| "full_run": full_run, |
| "gates": gates, |
| "all_evaluated_gates_passed": all(evaluated), |
| "invalid_examples": invalid_examples, |
| "source_group_split_conflicts": split_conflicts, |
| } |
|
|
|
|
| def _publish_reports( |
| output_root: Path, |
| config: dict[str, Any], |
| results: list[WorkerResult], |
| stats: StatsAccumulator, |
| gates: dict[str, Any], |
| *, |
| requested_records: int, |
| report_prefix: str, |
| ) -> tuple[Path, Path]: |
| shards = sorted((result.shard for result in results), key=lambda shard: str(shard.path)) |
| metadata = { |
| "dataset_name": config["dataset_name"], |
| "schema_version": config["schema_version"], |
| "generator_version": config["generator_version"], |
| "validator_version": config["validator_version"], |
| "config_sha256": _config_digest(config), |
| "requested_records": requested_records, |
| "synthetic_only": True, |
| "human_reviewed_records": 0, |
| "teacher_generated_records": 0, |
| } |
| manifest = build_manifest(shards, stats=stats, metadata=metadata) |
| manifest_path = output_root / f"{report_prefix}manifest.json" |
| write_json_atomic(manifest_path, manifest) |
| report = build_report(stats, metadata=metadata) |
| report["promotion_gates"] = gates |
| report_path = output_root / "reports" / f"{report_prefix}audit.json" |
| write_json_atomic(report_path, report) |
| return manifest_path, report_path |
|
|
|
|
| def _run_parallel_generate( |
| config: dict[str, Any], |
| output_root: Path, |
| requested_records: int, |
| workers: int, |
| ) -> list[WorkerResult]: |
| shard_size = int(config["shard_size"]) |
| tasks = [] |
| for shard_index, start in enumerate(range(0, requested_records, shard_size)): |
| end = min(requested_records, start + shard_size) |
| path = output_root / "canonical" / f"part-{shard_index:05d}.jsonl.gz" |
| tasks.append((config, str(path), start, end, int(config["gzip_compresslevel"]))) |
| results: list[WorkerResult] = [] |
| if workers == 1: |
| for shard_index, task in enumerate(tasks, 1): |
| result = _generate_shard(*task) |
| results.append(result) |
| print(f"generated {shard_index}/{len(tasks)} {result.shard.path.name}", flush=True) |
| return results |
| with ProcessPoolExecutor(max_workers=workers) as executor: |
| futures = {executor.submit(_generate_shard, *task): task[1] for task in tasks} |
| completed = 0 |
| for future in as_completed(futures): |
| path = futures.pop(future) |
| result = future.result() |
| results.append(result) |
| completed += 1 |
| print(f"generated {completed}/{len(tasks)} {Path(path).name}", flush=True) |
| return results |
|
|
|
|
| def command_generate(args: argparse.Namespace) -> int: |
| config = _load_config(args.config) |
| requested_records = int(args.limit or config["total_records"]) |
| if not 1 <= requested_records <= int(config["total_records"]): |
| raise ValueError("--limit must be between 1 and config.total_records") |
| output_root = Path(args.output).resolve() |
| if (output_root / "_SUCCESS.json").exists(): |
| raise FileExistsError(f"completed dataset already exists: {output_root}") |
| canonical = output_root / "canonical" |
| if canonical.exists() and any(canonical.iterdir()): |
| raise FileExistsError( |
| f"output canonical directory is not empty: {canonical}; choose a new output path" |
| ) |
| output_root.mkdir(parents=True, exist_ok=True) |
| write_json_atomic(output_root / "config.snapshot.json", config) |
| workers = max(1, min(int(args.workers), (requested_records + config["shard_size"] - 1) // config["shard_size"])) |
| results = _run_parallel_generate(config, output_root, requested_records, workers) |
| stats, split_conflicts, invalid_examples = _merge_worker_results(results) |
| gates = _promotion_gates( |
| config, |
| stats, |
| requested_records=requested_records, |
| split_conflicts=split_conflicts, |
| invalid_examples=invalid_examples, |
| ) |
| manifest_path, report_path = _publish_reports( |
| output_root, |
| config, |
| results, |
| stats, |
| gates, |
| requested_records=requested_records, |
| report_prefix="", |
| ) |
| success = { |
| "dataset_name": config["dataset_name"], |
| "records": requested_records, |
| "shards": len(results), |
| "manifest": str(manifest_path), |
| "manifest_sha256": sha256_file(manifest_path), |
| "audit": str(report_path), |
| "audit_sha256": sha256_file(report_path), |
| "all_evaluated_gates_passed": gates["all_evaluated_gates_passed"], |
| } |
| if not gates["all_evaluated_gates_passed"]: |
| write_json_atomic(output_root / "_FAILED_GATES.json", success | {"gates": gates}) |
| raise RuntimeError(f"generation gates failed; inspect {report_path}") |
| write_json_atomic(output_root / "_SUCCESS.json", success) |
| print(json.dumps(success, ensure_ascii=False, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| def _run_parallel_audit(manifest: dict[str, Any], workers: int) -> list[WorkerResult]: |
| shards = manifest.get("shards") |
| if not isinstance(shards, list) or not shards: |
| raise ValueError("manifest has no shards") |
| results: list[WorkerResult] = [] |
| if workers == 1: |
| for index, shard in enumerate(shards, 1): |
| result = _audit_shard(shard) |
| results.append(result) |
| print(f"audited {index}/{len(shards)} {Path(shard['path']).name}", flush=True) |
| return results |
| with ProcessPoolExecutor(max_workers=workers) as executor: |
| futures = {executor.submit(_audit_shard, shard): shard for shard in shards} |
| completed = 0 |
| for future in as_completed(futures): |
| shard = futures.pop(future) |
| results.append(future.result()) |
| completed += 1 |
| print(f"audited {completed}/{len(shards)} {Path(shard['path']).name}", flush=True) |
| return results |
|
|
|
|
| def command_audit(args: argparse.Namespace) -> int: |
| output_root = Path(args.output).resolve() |
| config = _load_config(args.config or output_root / "config.snapshot.json") |
| manifest_path = Path(args.manifest or output_root / "manifest.json") |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| requested_records = int(manifest["metadata"]["requested_records"]) |
| workers = max(1, min(int(args.workers), len(manifest["shards"]))) |
| results = _run_parallel_audit(manifest, workers) |
| stats, split_conflicts, invalid_examples = _merge_worker_results(results) |
| gates = _promotion_gates( |
| config, |
| stats, |
| requested_records=requested_records, |
| split_conflicts=split_conflicts, |
| invalid_examples=invalid_examples, |
| ) |
| _, report_path = _publish_reports( |
| output_root, |
| config, |
| results, |
| stats, |
| gates, |
| requested_records=requested_records, |
| report_prefix="postwrite-", |
| ) |
| verified = { |
| "dataset_name": config["dataset_name"], |
| "records": stats.total_records, |
| "shards": len(results), |
| "source_manifest": str(manifest_path), |
| "source_manifest_sha256": sha256_file(manifest_path), |
| "audit": str(report_path), |
| "audit_sha256": sha256_file(report_path), |
| "all_evaluated_gates_passed": gates["all_evaluated_gates_passed"], |
| } |
| if not gates["all_evaluated_gates_passed"]: |
| write_json_atomic(output_root / "_POSTWRITE_FAILED.json", verified | {"gates": gates}) |
| raise RuntimeError(f"post-write audit failed; inspect {report_path}") |
| write_json_atomic(output_root / "_VERIFIED.json", verified) |
| print(json.dumps(verified, ensure_ascii=False, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| def command_build(args: argparse.Namespace) -> int: |
| """Generate and then independently re-read every published shard.""" |
|
|
| generate_args = argparse.Namespace( |
| config=args.config, |
| output=args.output, |
| limit=args.limit, |
| workers=args.workers, |
| ) |
| generated = command_generate(generate_args) |
| if generated: |
| return generated |
| audit_args = argparse.Namespace( |
| output=args.output, |
| config=None, |
| manifest=None, |
| workers=args.workers, |
| ) |
| return command_audit(audit_args) |
|
|
|
|
| def command_show_plan(args: argparse.Namespace) -> int: |
| config = _load_config(args.config) |
| plan = GenerationPlan(config) |
| summary = { |
| "dataset_name": config["dataset_name"], |
| "total_records": config["total_records"], |
| "primitive_per_100": dict(sorted(Counter(plan.primitive_cycle).items())), |
| "mixture_per_100": dict(sorted(Counter(plan.mixture_cycle).items())), |
| "serializer_per_100": dict(sorted(Counter(plan.serializer_cycle).items())), |
| "long_slots": [ |
| { |
| "offset": offset, |
| "primitive": plan.primitive_cycle[offset], |
| "mixture": plan.mixture_cycle[offset], |
| } |
| for offset in plan.long_slots |
| ], |
| } |
| print(json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| def command_render_sample(args: argparse.Namespace) -> int: |
| config = _load_config(args.config) |
| plan = GenerationPlan(config) |
| record = generate_record(config, plan, int(args.index)) |
| print( |
| json.dumps( |
| {"record": record, "messages": build_messages(record)}, |
| ensure_ascii=False, |
| indent=2, |
| sort_keys=True, |
| ) |
| ) |
| return 0 |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description="Barbet BGD-SFT deterministic dataset builder") |
| subparsers = parser.add_subparsers(dest="command", required=True) |
|
|
| generate = subparsers.add_parser("generate", help="generate validated canonical shards") |
| generate.add_argument("--config", default=str(DEFAULT_CONFIG)) |
| generate.add_argument("--output", required=True) |
| generate.add_argument("--limit", type=int) |
| generate.add_argument("--workers", type=int, default=1) |
| generate.set_defaults(func=command_generate) |
|
|
| audit = subparsers.add_parser("audit", help="re-read, hash and semantically validate shards") |
| audit.add_argument("--output", required=True) |
| audit.add_argument("--config") |
| audit.add_argument("--manifest") |
| audit.add_argument("--workers", type=int, default=1) |
| audit.set_defaults(func=command_audit) |
|
|
| build = subparsers.add_parser( |
| "build", help="generate the dataset and independently post-write audit every shard" |
| ) |
| build.add_argument("--config", default=str(DEFAULT_CONFIG)) |
| build.add_argument("--output", required=True) |
| build.add_argument("--limit", type=int) |
| build.add_argument("--workers", type=int, default=1) |
| build.set_defaults(func=command_build) |
|
|
| show_plan = subparsers.add_parser("show-plan", help="print exact per-100 mixture") |
| show_plan.add_argument("--config", default=str(DEFAULT_CONFIG)) |
| show_plan.set_defaults(func=command_show_plan) |
|
|
| render = subparsers.add_parser("render-sample", help="render one canonical record as SFT messages") |
| render.add_argument("--config", default=str(DEFAULT_CONFIG)) |
| render.add_argument("--index", type=int, default=0) |
| render.set_defaults(func=command_render_sample) |
| return parser |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| parser = build_parser() |
| args = parser.parse_args(argv) |
| try: |
| return int(args.func(args)) |
| except Exception as exc: |
| print(f"ERROR: {exc}", file=sys.stderr) |
| return 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
