| |
| """Build a QAD-ready student dataset from a clean calibration. |
| |
| QAD needs three things that the generic INT4 conversion does not hand you in one |
| place: |
| |
| 1. a student whose ``config.json`` is the raw lalamo form (``response_format`` |
| present); conversion rewrites the config for uzu |
| 2. a ``provenance.json`` with ``overlap_checked: true``; QAD refuses a student |
| without it |
| 3. a tokenizer identical to the teacher |
| |
| This script runs calibration -> convert -> lalamo copy, copies the provenance |
| next to the student, verifies all three conditions, and writes a manifest that |
| can be uploaded as a Kaggle dataset. |
| |
| Usage: |
| python scripts/make_qad_dataset.py \ |
| --bf16 /kaggle/working/bf16-lalamo \ |
| --out /kaggle/working/qad-student \ |
| --corpus data/calibration_mixed_en_ja_dedup.txt \ |
| --eval-corpus data/eval_en_wikitext2_dedup.txt \ |
| --eval-corpus data/eval_ja_wikipedia_dedup.txt \ |
| --kaggle-id <user>/uzu-qad-08b-clean |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import shutil |
| import subprocess |
| import sys |
| from pathlib import Path |
|
|
| HERE = Path(__file__).resolve().parent |
|
|
|
|
| def sha256(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def run(command: list[str], dry_run: bool) -> None: |
| print("$ " + " ".join(str(part) for part in command), flush=True) |
| if dry_run: |
| return |
| subprocess.run([str(part) for part in command], check=True) |
|
|
|
|
| def validate_student(bf16: Path, student: Path) -> list[str]: |
| """Return the reasons QAD would refuse this student.""" |
| problems: list[str] = [] |
| config = json.loads((student / "config.json").read_text(encoding="utf-8")) |
| if "response_format" not in config.get("token_codec_config", {}): |
| problems.append("student config is uzu-normalized (no response_format)") |
|
|
| provenance_path = student / "provenance.json" |
| if not provenance_path.exists(): |
| problems.append("student provenance.json missing") |
| else: |
| provenance = json.loads(provenance_path.read_text(encoding="utf-8")) |
| if not provenance.get("overlap_checked"): |
| problems.append("student provenance says overlap_checked=false") |
|
|
| bf16_tokenizer = bf16 / "tokenizer.json" |
| student_tokenizer = student / "tokenizer.json" |
| if not student_tokenizer.exists(): |
| problems.append("student tokenizer.json missing") |
| elif bf16_tokenizer.exists() and sha256(bf16_tokenizer) != sha256(student_tokenizer): |
| problems.append("student tokenizer.json differs from bf16") |
|
|
| for name in ("model.safetensors",): |
| if not (student / name).exists(): |
| problems.append(f"student {name} missing") |
| return problems |
|
|
|
|
| def plan_kaggle_upload(out: Path, public: bool, message: str, exists: bool) -> list[str]: |
| """First upload creates the dataset; later ones add a version.""" |
| if exists: |
| return ["kaggle", "datasets", "version", "-p", str(out), "-m", message, "-r", "zip", "-q"] |
| command = ["kaggle", "datasets", "create", "-p", str(out), "-r", "zip", "-q"] |
| if public: |
| command.append("-u") |
| return command |
|
|
|
|
| def upload_to_kaggle(out: Path, public: bool, message: str, dry_run: bool) -> int: |
| create = plan_kaggle_upload(out, public, message, exists=False) |
| print("$ " + " ".join(create), flush=True) |
| if dry_run: |
| return 0 |
| first = subprocess.run(create, check=False) |
| if first.returncode == 0: |
| return 0 |
| version = plan_kaggle_upload(out, public, message, exists=True) |
| print("create failed; trying a new version", flush=True) |
| print("$ " + " ".join(version), flush=True) |
| return subprocess.run(version, check=False).returncode |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--bf16", type=Path, required=True, help="raw lalamo BF16 directory") |
| parser.add_argument("--out", type=Path, required=True) |
| parser.add_argument("--corpus", type=Path, required=True, help="calibration corpus") |
| parser.add_argument("--eval-corpus", type=Path, action="append", required=True) |
| parser.add_argument("--samples", type=int, default=32) |
| parser.add_argument("--max-tokens", type=int, default=128) |
| parser.add_argument("--output-block", default="small") |
| parser.add_argument("--output-block-limit", type=int, default=2048) |
| parser.add_argument("--damping", type=float, default=1e-3) |
| parser.add_argument("--parallel", default="tensor") |
| parser.add_argument( |
| "--layer-bits-json", |
| type=Path, |
| default=None, |
| help="per-layer bit overrides for the student, e.g. lanes/bits-wide-8.json", |
| ) |
| parser.add_argument("--quantize-embedding", action="store_true") |
| parser.add_argument("--embedding-bits", type=int, default=None, choices=(4, 8)) |
| parser.add_argument("--calibration-json", type=Path, default=None, help="reuse an existing calibration.json") |
| parser.add_argument("--calibration-npz", type=Path, default=None, help="reuse an existing calibration.npz") |
| parser.add_argument("--kaggle-id", default=None, help="write dataset-metadata.json for this Kaggle id") |
| parser.add_argument("--kaggle-upload", action="store_true", help="create or version the Kaggle dataset after validating") |
| parser.add_argument("--kaggle-public", action="store_true", help="create the dataset as public") |
| parser.add_argument("--kaggle-message", default="QAD student (clean calibration)") |
| parser.add_argument("--dry-run", action="store_true") |
| args = parser.parse_args() |
|
|
| out = args.out |
| calibration_json = args.calibration_json or (out / "calibration.json") |
| calibration_npz = args.calibration_npz or (out / "calibration.npz") |
| int4_dir = out / "int4" |
| student = out / "student" |
|
|
| if args.dry_run or not calibration_npz.exists(): |
| command = [ |
| sys.executable, |
| str(HERE / "yaqa_calibration.py"), |
| "--model-dir", |
| str(args.bf16), |
| "--corpus", |
| str(args.corpus), |
| "--output", |
| str(calibration_npz), |
| "--json-out", |
| str(calibration_json), |
| "--samples", |
| str(args.samples), |
| "--max-tokens", |
| str(args.max_tokens), |
| "--output-block", |
| str(args.output_block), |
| "--output-block-limit", |
| str(args.output_block_limit), |
| "--damping", |
| str(args.damping), |
| "--parallel", |
| args.parallel, |
| ] |
| for corpus in args.eval_corpus: |
| command += ["--eval-corpus", str(corpus)] |
| run(command, args.dry_run) |
|
|
| run( |
| [ |
| sys.executable, |
| str(HERE / "rht_int4_convert.py"), |
| "--load-from", |
| str(args.bf16), |
| "--output-dir", |
| str(int4_dir), |
| "--preconditioners", |
| str(calibration_npz), |
| "--calibration-json", |
| str(calibration_json), |
| "--parallel", |
| args.parallel, |
| ] |
| + ( |
| ["--layer-bits-json", str(args.layer_bits_json)] |
| if args.layer_bits_json |
| else [] |
| ) |
| + (["--quantize-embedding"] if args.quantize_embedding else []) |
| + ( |
| ["--embedding-bits", str(args.embedding_bits)] |
| if args.embedding_bits is not None |
| else [] |
| ), |
| args.dry_run, |
| ) |
| run( |
| [ |
| sys.executable, |
| str(HERE / "make_lalamo_eval_copy.py"), |
| "--source", |
| str(int4_dir), |
| "--dest", |
| str(student), |
| ], |
| args.dry_run, |
| ) |
|
|
| if args.dry_run: |
| print("[dry-run] would copy provenance.json and validate") |
| return |
|
|
| provenance_source = int4_dir / "provenance.json" |
| if not provenance_source.exists(): |
| raise SystemExit(f"conversion did not write provenance: {provenance_source}") |
| shutil.copy2(provenance_source, student / "provenance.json") |
|
|
| problems = validate_student(args.bf16, student) |
| if problems: |
| print("STUDENT INVALID") |
| for problem in problems: |
| print(f" - {problem}") |
| raise SystemExit(1) |
|
|
| provenance = json.loads((student / "provenance.json").read_text(encoding="utf-8")) |
| manifest = { |
| "kind": "qad-student", |
| "teacher": str(args.bf16), |
| "student": str(student), |
| "calibration": { |
| "corpus": str(args.corpus), |
| "eval_corpora": [str(corpus) for corpus in args.eval_corpus], |
| "samples": args.samples, |
| "max_tokens": args.max_tokens, |
| "output_block": args.output_block, |
| "damping": args.damping, |
| "corpus_sha256": [sha256(corpus) for corpus in [args.corpus, *args.eval_corpus]], |
| }, |
| "provenance_sha256": sha256(student / "provenance.json"), |
| "provenance_kind": provenance.get("kind"), |
| "overlap_checked": bool(provenance.get("overlap_checked")), |
| "tokenizer_sha256": sha256(student / "tokenizer.json"), |
| } |
| (out / "qad_dataset.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
| if args.kaggle_id: |
| metadata = { |
| "title": args.kaggle_id.split("/")[-1].replace("-", " "), |
| "id": args.kaggle_id, |
| "licenses": [{"name": "Apache-2.0"}], |
| "subtitle": "QAD student with clean calibration provenance", |
| "description": ( |
| "Student produced by clean YAQA calibration (calibration and eval corpora are disjoint) " |
| "for uzu QAD. Contains student/, calibration.json, qad_dataset.json.\n\n" |
| f"teacher: {args.bf16}\ncorpus: {args.corpus}\n" |
| "See qad_dataset.json for hashes." |
| ), |
| "resources": [], |
| } |
| (out / "dataset-metadata.json").write_text(json.dumps(metadata, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
| print(f"student ready: {student}") |
| print(f"manifest: {out / 'qad_dataset.json'}") |
|
|
| if args.kaggle_upload: |
| if not args.kaggle_id: |
| raise SystemExit("--kaggle-upload needs --kaggle-id") |
| if not (out / "dataset-metadata.json").exists(): |
| raise SystemExit("missing dataset-metadata.json; pass --kaggle-id") |
| code = upload_to_kaggle(out, args.kaggle_public, args.kaggle_message, args.dry_run) |
| if code != 0: |
| raise SystemExit(f"kaggle upload failed with code {code}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
