| |
| """Assemble or check the public quantization kit (scripts + corpora). |
| |
| The Kaggle/HF kit is a copy of a fixed file list. Copying by hand is how |
| ``rewrite_lalamo_hybrid_spec.py`` went missing even though |
| ``rht_int4_convert.py`` imports it lazily. This script is the single source of |
| truth for what goes in, so the kit can be rebuilt and verified. |
| |
| Usage: |
| python scripts/build_kit.py --output /tmp/uzu-kit |
| python scripts/build_kit.py --check /tmp/uzu-kit |
| python scripts/build_kit.py --list |
| |
| A kit is valid when: |
| - every file in KIT_FILES exists |
| - every ``import <local_module>`` / ``from <local_module> import`` inside the |
| kit resolves to a file in the kit |
| - every script compiles |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| import hashlib |
| import json |
| import shutil |
| import subprocess |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
| KIT_SCRIPTS = [ |
| |
| "rht_int4_convert.py", |
| "rewrite_lalamo_hybrid_spec.py", |
| "normalize_lalamo_config.py", |
| "make_lalamo_eval_copy.py", |
| "yaqa_calibration.py", |
| "merge_language_hessians.py", |
| "merge_calibration_groups.py", |
| "eval_quantized.py", |
| "eval_external_model.py", |
| "quantize_speculator.py", |
| "qad_finetune.py", |
| "compute_bpc.py", |
| "run_lane.py", |
| "make_sweep_spec.py", |
| "make_smoke_specs.py", |
| "combine_lane_manifests.py", |
| "make_qad_dataset.py", |
| "ag_fetch.py", |
| "lalamo_forward.py", |
| "kaggle_usage.py", |
| "eval_generation.py", |
| "pull_results.py", |
| |
| "corpus_guard.py", |
| "dedup_lines.py", |
| "dedup_calibration.py", |
| "check_experiment.py", |
| "check_docs.py", |
| "preflight.py", |
| "env_fingerprint.py", |
| "kaggle_slots.py", |
| "publish_results.py", |
| |
| "tiny_sharding_probe.py", |
| "audit_public_corpus.py", |
| |
| "build_kit.py", |
| "bootstrap_kaggle.py", |
| ] |
|
|
| KIT_DATA = [ |
| "calibration_en_wikitext2_dedup.txt", |
| "calibration_ja_wikipedia_dedup.txt", |
| "calibration_mixed_en_ja_dedup.txt", |
| "calibration_mixed_ja35_en65_dedup.txt", |
| "calibration_mixed_ja65_en35_dedup.txt", |
| "eval_en_wikitext2_dedup.txt", |
| "eval_ja_wikipedia_dedup.txt", |
| ] |
|
|
| KIT_LANES = sorted(path.name for path in (ROOT / "lanes").glob("*") if path.is_file()) |
|
|
| KIT_TESTS = [ |
| "test_experiment_guards.py", |
| "test_compute_bpc.py", |
| "test_run_lane.py", |
| "test_tiny_sharding.py", |
| ] |
|
|
| DATA_ROOT = ROOT / "experiments" / "qwen35-0.8b" / "data" |
|
|
|
|
| def sha256(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def source_commit() -> str | None: |
| try: |
| return subprocess.run( |
| ["git", "rev-parse", "HEAD"], cwd=ROOT, text=True, capture_output=True, check=False |
| ).stdout.strip() or None |
| except OSError: |
| return None |
|
|
|
|
| def build(output: Path) -> list[str]: |
| copied: list[str] = [] |
| layout = { |
| "scripts": [(ROOT / "scripts" / name, name) for name in KIT_SCRIPTS], |
| "data": [(DATA_ROOT / name, name) for name in KIT_DATA], |
| "lanes": [(ROOT / "lanes" / name, name) for name in KIT_LANES], |
| "tests": [(ROOT / "tests" / name, name) for name in KIT_TESTS], |
| "configs": [(ROOT / "experiments" / model / "config.json", f"{model}.json") for model in ("qwen35-0.8b", "qwen35-4b", "qwen35-9b")], |
| } |
| for subdir, entries in layout.items(): |
| target_dir = output / subdir |
| target_dir.mkdir(parents=True, exist_ok=True) |
| for source, name in entries: |
| if not source.exists(): |
| raise SystemExit(f"missing source: {source}") |
| shutil.copy2(source, target_dir / name) |
| copied.append(f"{subdir}/{name}") |
|
|
| MANIFEST_NAME = "kit_manifest.json" |
| manifest = { |
| "built_from_commit": source_commit(), |
| |
| |
| "capabilities": detect_capabilities(output), |
| "files": { |
| name: sha256(output / name) for name in copied |
| }, |
| } |
| (output / MANIFEST_NAME).write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") |
| return copied |
|
|
|
|
| def detect_capabilities(root: Path) -> list[str]: |
| """Features a consumer may depend on, independent of the commit hash.""" |
| wanted = { |
| "rht_int4_convert.layer_filter": ("scripts/rht_int4_convert.py", "--layer-filter"), |
| "eval_quantized.dtype": ("scripts/eval_quantized.py", "--dtype"), |
| "preflight": ("scripts/preflight.py", "def verdict"), |
| "preflight.sdpa_xla": ("scripts/preflight.py", "sdpa_xla"), |
| "preflight.real_shapes": ("scripts/preflight.py", "jnp.ones((512, 1024)"), |
| "env_fingerprint": ("scripts/env_fingerprint.py", "lalamo_code_hashes"), |
| "qad.freeze_scales": ("scripts/qad_finetune.py", "--freeze-scales"), |
| "qad.early_stop_nonfatal": ("scripts/qad_finetune.py", "def early_stop_decision"), |
| "lane.exclude": ("scripts/run_lane.py", "--exclude"), |
| "lane.continue_on_failure": ("scripts/run_lane.py", "def run_conditions"), |
| "lane.resume_hf_results": ("scripts/run_lane.py", "def pull"), |
| "attention.auto_xla": ("scripts/lalamo_forward.py", "def gpu_capabilities"), |
| "attention.f32_activations": ("scripts/lalamo_forward.py", "def force_float32_activations"), |
| "attention.mesh_context": ("scripts/lalamo_forward.py", "def enter_mesh"), |
| } |
| found = [] |
| for name, (relative, needle) in wanted.items(): |
| path = root / relative |
| try: |
| text = path.read_text(encoding="utf-8") |
| except OSError: |
| continue |
| if needle in text: |
| found.append(name) |
| return found |
|
|
|
|
| def local_modules(scripts: list[Path]) -> dict[str, set[str]]: |
| """Map module name -> places where it is imported, for kit-local modules.""" |
| available = {path.stem for path in scripts} |
| imported: dict[str, set[str]] = {} |
| for path in scripts: |
| tree = ast.parse(path.read_text(encoding="utf-8")) |
| for node in ast.walk(tree): |
| names: list[str] = [] |
| if isinstance(node, ast.Import): |
| names = [alias.name.split(".")[0] for alias in node.names] |
| elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0: |
| names = [node.module.split(".")[0]] |
| for name in names: |
| if name in available and name != path.stem: |
| imported.setdefault(name, set()).add(path.name) |
| return imported |
|
|
|
|
| def check(kit: Path) -> list[str]: |
| problems: list[str] = [] |
| for subdir, names in ( |
| ("scripts", KIT_SCRIPTS), |
| ("data", KIT_DATA), |
| ("lanes", KIT_LANES), |
| ("tests", KIT_TESTS), |
| ): |
| for name in names: |
| if not (kit / subdir / name).exists(): |
| problems.append(f"missing {subdir}/{name}") |
|
|
| scripts = sorted((kit / "scripts").glob("*.py")) |
| if not scripts: |
| return problems + ["no scripts in kit"] |
| for path in scripts: |
| try: |
| compile(path.read_text(encoding="utf-8"), str(path), "exec") |
| except SyntaxError as error: |
| problems.append(f"syntax error in {path.name}: {error}") |
|
|
| manifest_path = kit / "kit_manifest.json" |
| if manifest_path.exists(): |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| for name, expected in manifest.get("files", {}).items(): |
| target = kit / name |
| if target.exists() and sha256(target) != expected: |
| problems.append(f"hash mismatch: {name}") |
| print(f"built_from_commit: {manifest.get('built_from_commit')}") |
|
|
| for module, importers in local_modules(scripts).items(): |
| if not (kit / "scripts" / f"{module}.py").exists(): |
| problems.append( |
| f"missing scripts/{module}.py imported by {', '.join(sorted(importers))}" |
| ) |
| return problems |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--output", type=Path, default=None, help="build the kit here") |
| parser.add_argument("--check", type=Path, default=None, help="verify an existing kit") |
| parser.add_argument("--list", action="store_true", help="print the manifest as JSON") |
| args = parser.parse_args() |
|
|
| if args.list: |
| print( |
| json.dumps( |
| {"scripts": KIT_SCRIPTS, "data": KIT_DATA, "lanes": KIT_LANES, "tests": KIT_TESTS}, |
| indent=2, |
| ) |
| ) |
| return |
| if args.output: |
| copied = build(args.output) |
| print(f"wrote {len(copied)} files to {args.output}") |
| problems = check(args.output) |
| elif args.check: |
| problems = check(args.check) |
| else: |
| parser.error("pass --output, --check, or --list") |
|
|
| if problems: |
| print("KIT INVALID") |
| for problem in problems: |
| print(f" - {problem}") |
| raise SystemExit(1) |
| print("KIT OK") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
