| |
| """Run a quantization experiment lane from a JSON spec. |
| |
| The point is that the owner defines an experiment as data and the Kaggle |
| operator only runs it. Every step still goes through the existing scripts, so |
| guards and provenance stay in force: |
| |
| yaqa_calibration.py -> rht_int4_convert.py -> make_lalamo_eval_copy.py -> eval_quantized.py |
| (+ merge_language_hessians.py when the spec asks for a language-balanced merge) |
| |
| Usage: |
| python scripts/run_lane.py --spec lanes/clean-suite-08b.json --dry-run |
| python scripts/run_lane.py --spec lanes/clean-suite-08b.json |
| python scripts/run_lane.py --spec lanes/clean-suite-08b.json --hf-results <user>/uzu-results |
| |
| Resume is the default: a condition whose ``result.json`` exists and passes the |
| sanity checks is skipped, so a kernel that dies at the 12h limit can be rerun. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import shutil |
| import subprocess |
| import sys |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
| DEFAULT_CONDITION = { |
| "samples": 32, |
| "calib_dtype": "float32", |
| "max_tokens": 128, |
| "output_block": "small", |
| "output_block_limit": 2048, |
| "damping": 1e-3, |
| "raw_output": False, |
| } |
| DEFAULT_EVAL = {"max_sequences": 100, "max_tokens": 128, "min_tokens": 16} |
| TRITON_MIN_CAPABILITY = 8.0 |
|
|
|
|
| def parse_compute_capabilities(output: str) -> list[float]: |
| capabilities = [] |
| for line in output.splitlines(): |
| text = line.strip().split(",")[0].strip() |
| try: |
| capabilities.append(float(text)) |
| except ValueError: |
| continue |
| return capabilities |
|
|
|
|
| def needs_triton_off(capabilities: list[float]) -> bool: |
| """XLA's Triton GEMM path only supports Ampere (cc 8.0) and newer.""" |
| return any(capability < TRITON_MIN_CAPABILITY for capability in capabilities) |
|
|
|
|
| def detect_compute_capabilities() -> list[float]: |
| try: |
| result = subprocess.run( |
| ["nvidia-smi", "--query-gpu=compute_cap", "--format=csv,noheader"], |
| text=True, |
| capture_output=True, |
| check=False, |
| timeout=20, |
| ) |
| except (OSError, subprocess.TimeoutExpired): |
| return [] |
| if result.returncode != 0: |
| return [] |
| return parse_compute_capabilities(result.stdout) |
|
|
|
|
| def find_dataset_dir(root: Path, name: str) -> Path | None: |
| """Locate a mounted dataset regardless of the /kaggle/input layout.""" |
| candidates = [ |
| root / name, |
| *sorted(root.glob(f"datasets/*/{name}")), |
| *sorted(root.glob(f"datasets/*/*/{name}")), |
| ] |
| for candidate in candidates: |
| if (candidate / "model.safetensors").exists(): |
| return candidate |
| |
| for weights in sorted(root.rglob("model.safetensors")): |
| directory = weights.parent |
| if (directory / "tokenizer.json").exists(): |
| return directory |
| return None |
|
|
|
|
| try: |
| from env_fingerprint import fingerprint, lalamo_provenance, parse_direct_url |
| except Exception: |
| def parse_direct_url(text: str) -> dict[str, str]: |
| return {} |
|
|
| def lalamo_provenance() -> dict[str, str]: |
| return {} |
|
|
| def fingerprint() -> dict[str, str]: |
| return {} |
|
|
|
|
| class Runner: |
| def __init__(self, spec: dict[str, Any], spec_path: Path, *, dry_run: bool = False) -> None: |
| self.spec = spec |
| self.spec_path = spec_path |
| self.dry_run = dry_run |
| self.commands: list[list[str]] = [] |
|
|
| paths = spec.get("paths", {}) |
| kit = Path(paths.get("kit", "kit")).expanduser() |
| work = Path(paths.get("work", "/kaggle/working")).expanduser() |
| self.kit = kit |
| self.work = work |
| self.scripts = { |
| "preflight": self._script(paths.get("preflight", "scripts/preflight.py")), |
| "calibrate": self._script(paths.get("calibrate", "scripts/yaqa_calibration.py")), |
| "convert": self._script(paths.get("convert", "scripts/rht_int4_convert.py")), |
| "merge": self._script(paths.get("merge", "scripts/merge_language_hessians.py")), |
| "eval": self._script(paths.get("eval", "scripts/eval_quantized.py")), |
| "copy": self._script(paths.get("copy", "scripts/make_lalamo_eval_copy.py")), |
| } |
| self.lane = spec.get("lane") or spec_path.stem |
| self.preflight: dict | None = None |
| capabilities = detect_compute_capabilities() |
| self.triton_off = needs_triton_off(capabilities) |
| |
| |
| configured_dtype = (spec.get("eval") or {}).get("dtype") |
| self.eval_dtype = configured_dtype or ("float32" if self.triton_off else "bfloat16") |
| if self.triton_off and configured_dtype == "bfloat16": |
| print("GPU cannot do BF16 matmul; overriding eval dtype to float32", flush=True) |
| self.eval_dtype = "float32" |
| if self.triton_off: |
| print( |
| f"GPU caps {capabilities}: disabling XLA Triton GEMM (needs >= {TRITON_MIN_CAPABILITY})", |
| flush=True, |
| ) |
| self.lane_dir = work / "out" / self.lane |
| self.jax_platform = paths.get("jax_platform") or os.environ.get("JAX_PLATFORM_NAME") or None |
|
|
| |
|
|
| def _script(self, relative: str) -> Path: |
| path = Path(relative) |
| return path if path.is_absolute() else self.kit / path |
|
|
| def resolve(self, value: str | None) -> Path | None: |
| if value is None: |
| return None |
| path = Path(value).expanduser() |
| return path if path.is_absolute() else self.kit / path |
|
|
| def env_provenance(self) -> dict[str, str]: |
| """Environment knobs that change numerics must travel with the results.""" |
| prefixes = ("XLA_FLAGS", "JAX_", "UZU_") |
| seen = {} |
| for key, value in self.environment().items(): |
| if key.startswith(prefixes): |
| seen[key] = value |
| try: |
| from importlib.metadata import version |
|
|
| seen["jax_version"] = version("jax") |
| except Exception: |
| pass |
| seen.update(lalamo_provenance()) |
| return seen |
|
|
| def environment(self, base: dict[str, str] | None = None) -> dict[str, str]: |
| env = dict(os.environ if base is None else base) |
| if self.jax_platform: |
| env["JAX_PLATFORM_NAME"] = self.jax_platform |
| for key, value in (self.spec.get("paths", {}).get("env") or {}).items(): |
| env[str(key)] = str(value) |
| flags = list(self.spec.get("paths", {}).get("xla_flags", [])) |
| if self.triton_off: |
| flags.append("--xla_gpu_enable_triton_gemm=false") |
| |
| |
| env.setdefault("UZU_ATTENTION_IMPL", "xla") |
| existing = env.get("XLA_FLAGS", "") |
| for flag in flags: |
| if flag not in existing: |
| existing = (existing + " " + flag).strip() |
| if existing: |
| env["XLA_FLAGS"] = existing |
| return env |
|
|
| def run(self, step: str, command: list[str], log: Path) -> None: |
| display = " ".join(str(part) for part in command) |
| print(f"$ {display}", flush=True) |
| self.commands.append([str(part) for part in command]) |
| if self.dry_run: |
| return |
| env = self.environment() |
| started = time.time() |
| with log.open("a", encoding="utf-8") as handle: |
| handle.write(f"\n=== {step} {time.strftime('%H:%M:%S')} ===\n$ {display}\n") |
| handle.flush() |
| result = subprocess.run(command, stdout=handle, stderr=subprocess.STDOUT, env=env, check=False) |
| if result.returncode != 0: |
| raise SystemExit(f"{step} failed with code {result.returncode}; see {log}") |
| print(f" {step} ok ({time.time() - started:.0f}s)", flush=True) |
|
|
| |
|
|
| def run_preflight(self) -> dict | None: |
| """Refuse to burn ten minutes on a GPU that cannot run the attention path.""" |
| script = self.scripts.get("preflight") |
| if script is None or not Path(script).exists() or self.dry_run: |
| return None |
| report_path = self.lane_dir / "preflight.json" |
| command = [sys.executable, str(script), "--json", str(report_path)] |
| env = self.environment() |
| result = subprocess.run(command, text=True, capture_output=True, env=env, check=False) |
| print(result.stdout.strip()[:800], flush=True) |
| if result.returncode != 0 or not report_path.exists(): |
| print(f"preflight failed to produce a report (rc={result.returncode})", flush=True) |
| return None |
| report = json.loads(report_path.read_text(encoding="utf-8")) |
| probes = report.get("probes") or {} |
| if probes.get("quant_roundtrip") == "fail": |
| error = (report.get("probe_errors") or {}).get("quant_roundtrip", "") |
| raise SystemExit( |
| "preflight: lalamo has no working RHT quantize/dequantize path. " |
| "This is the PyPI 0.17.0 trap: install " |
| "git+https://github.com/trymirai/lalamo@e401e177 instead. " |
| f"{error}".strip() |
| ) |
| if (self.jax_platform or "").startswith("gpu") and report.get("attention") == "unavailable": |
| raise SystemExit( |
| "preflight: dot_product_attention is unavailable on this GPU " |
| f"({report.get('gpu_names')}). Use --jax-platform cpu or Modal." |
| ) |
| return report |
|
|
| def ensure_bf16(self) -> Path: |
| """Return a lalamo-loadable BF16 directory. |
| |
| The import path (rht_int4_convert --dry-run) normalizes config.json for |
| uzu: it drops ``response_format`` and adds ``output_parser_regex`` / |
| ``end_of_thinking_tag``. Pinned lalamo refuses that schema, so |
| calibration cannot load the imported directory directly. The import is |
| therefore written to a raw directory and ``make_lalamo_eval_copy`` |
| produces the loadable copy that both calibration and eval use. |
| """ |
| model = self.spec.get("model", {}) |
| target = self.resolve(model.get("bf16_dir", "bf16-lalamo")) |
| assert target is not None |
| if (target / "model.safetensors").exists(): |
| return target |
|
|
| source = self.resolve(model.get("bf16_source")) |
| if source and not (source / "model.safetensors").exists() and model.get("bf16_source_auto"): |
| found = find_dataset_dir(Path("/kaggle/input"), source.name) |
| if found is not None: |
| print(f"bf16 source resolved to {found}", flush=True) |
| source = found |
| if source and (source / "model.safetensors").exists(): |
| print(f"copy bf16 from {source} -> {target}", flush=True) |
| if not self.dry_run: |
| shutil.copytree(source, target, dirs_exist_ok=True) |
| return target |
|
|
| raw = self.resolve(model.get("bf16_raw_dir", "bf16-raw")) |
| assert raw is not None |
| if not (raw / "model.safetensors").exists(): |
| command = [ |
| sys.executable, |
| str(self.scripts["convert"]), |
| "--spec-name", |
| model.get("spec_name", "Qwen3.5-0.8B"), |
| "--output-dir", |
| str(self.work / "import"), |
| "--dry-run", |
| "--bf16-dir", |
| str(raw), |
| ] |
| if model.get("hf_repo"): |
| command += ["--hf-repo", model["hf_repo"]] |
| if model.get("hf_dir"): |
| command += ["--hf-dir", str(self.resolve(model["hf_dir"]))] |
| self.run("bf16 import", command, self.lane_dir / "lane.log") |
|
|
| self.run( |
| "bf16 lalamo copy", |
| [sys.executable, str(self.scripts["copy"]), "--source", str(raw), "--dest", str(target)], |
| self.lane_dir / "lane.log", |
| ) |
| return target |
|
|
| def eval_corpora(self) -> dict[str, Path]: |
| corpora = self.spec.get("eval", {}).get("corpora", {}) |
| if not corpora: |
| raise SystemExit("spec.eval.corpora is empty") |
| resolved = {} |
| for lang, path in corpora.items(): |
| target = self.resolve(path) |
| assert target is not None |
| resolved[lang] = target |
| return resolved |
|
|
| def condition_settings(self, condition: dict[str, Any]) -> dict[str, Any]: |
| settings = dict(DEFAULT_CONDITION) |
| settings.update(self.spec.get("condition_defaults", {})) |
| settings.update({key: value for key, value in condition.items() if key not in ("name", "calibration_corpus")}) |
| return settings |
|
|
| def existing_result(self, name: str) -> dict[str, Any] | None: |
| path = self.lane_dir / name / "result.json" |
| if not path.exists(): |
| return None |
| try: |
| payload = json.loads(path.read_text(encoding="utf-8")) |
| except json.JSONDecodeError: |
| return None |
| if payload.get("status") != "complete": |
| return None |
| return payload |
|
|
| def evaluate(self, name: str, candidate: Path, bf16: Path) -> dict[str, Any]: |
| out = self.lane_dir / name |
| base = read_json(out / "calibration.json") or {} |
| summary: dict[str, Any] = { |
| "name": name, |
| "calibration": { |
| "corpus": base.get("corpus"), |
| "samples": base.get("samples"), |
| "max_tokens": base.get("max_tokens"), |
| "output_block": base.get("output_block"), |
| "damping": base.get("damping"), |
| "calib_dtype": base.get("calib_dtype"), |
| "raw_output": base.get("raw_output"), |
| "ja_ratio": base.get("ja_ratio"), |
| "overlap_checked": base.get("overlap_checked"), |
| }, |
| "ppl": {}, |
| } |
| for lang, corpus in self.eval_corpora().items(): |
| json_out = out / f"ppl_{lang}.json" |
| self.run( |
| f"{name} eval {lang}", |
| [ |
| sys.executable, |
| str(self.scripts["eval"]), |
| "--bf16-dir", |
| str(bf16), |
| "--candidate-dir", |
| str(candidate), |
| "--corpus", |
| str(corpus), |
| "--max-sequences", |
| str(self.spec.get("eval", {}).get("max_sequences", DEFAULT_EVAL["max_sequences"])), |
| "--max-tokens", |
| str(self.spec.get("eval", {}).get("max_tokens", DEFAULT_EVAL["max_tokens"])), |
| "--dtype", |
| str(self.eval_dtype), |
| "--min-tokens", |
| str(self.spec.get("eval", {}).get("min_tokens", DEFAULT_EVAL["min_tokens"])), |
| "--json-out", |
| str(json_out), |
| ], |
| out / "lane.log", |
| ) |
| payload = read_json(json_out) or {} |
| summary["ppl"][lang] = { |
| key: payload.get(key) |
| for key in ( |
| "chunks", |
| "tokens", |
| "bf16_ppl", |
| "candidate_ppl", |
| "delta_nll_per_token", |
| "config_hash", |
| ) |
| } |
| return summary |
|
|
| def run_condition(self, condition: dict[str, Any], bf16: Path) -> dict[str, Any]: |
| name = condition["name"] |
| out = self.lane_dir / name |
| if not self.dry_run: |
| out.mkdir(parents=True, exist_ok=True) |
| settings = self.condition_settings(condition) |
| if self.triton_off and str(settings.get("calib_dtype")) == "bfloat16": |
| print(f"{name}: BF16 calibration is unsupported on this GPU; using float32", flush=True) |
| settings["calib_dtype"] = "float32" |
| is_rtn = bool(condition.get("rtn")) |
| corpus = self.resolve(condition.get("calibration_corpus")) if not is_rtn else None |
| if not is_rtn and corpus is None: |
| raise SystemExit(f"{name}: calibration_corpus is required unless rtn=true") |
|
|
| existing = self.existing_result(name) |
| if existing is not None: |
| print(f"skip {name}: result.json already complete", flush=True) |
| return existing |
|
|
| skip_convert = (not is_rtn) and (bool(condition.get("skip_convert")) or ( |
| settings.get("raw_output") and bool(self.spec.get("merge")) and not condition.get("force_convert") |
| )) |
| calib_npz = out / "calibration.npz" |
| if is_rtn: |
| print(f"{name}: RTN (no calibration)", flush=True) |
| elif not calib_npz.exists(): |
| command = [ |
| sys.executable, |
| str(self.scripts["calibrate"]), |
| "--model-dir", |
| str(bf16), |
| "--corpus", |
| str(corpus), |
| "--output", |
| str(calib_npz), |
| "--json-out", |
| str(out / "calibration.json"), |
| "--samples", |
| str(settings["samples"]), |
| "--max-tokens", |
| str(settings["max_tokens"]), |
| "--output-block", |
| str(settings["output_block"]), |
| "--output-block-limit", |
| str(settings["output_block_limit"]), |
| "--damping", |
| str(settings["damping"]), |
| ] |
| for eval_corpus in self.eval_corpora().values(): |
| command += ["--eval-corpus", str(eval_corpus)] |
| if settings.get("calib_dtype"): |
| command += ["--calib-dtype", str(settings["calib_dtype"])] |
| if settings.get("seed") is not None: |
| command += ["--seed", str(settings["seed"])] |
| if settings.get("raw_output"): |
| command.append("--raw-output") |
| if self.spec.get("convert", {}).get("parallel"): |
| command += ["--parallel", str(self.spec["convert"]["parallel"])] |
| self.run(f"{name} calibration", command, out / "lane.log") |
|
|
| if skip_convert: |
| summary = { |
| "name": name, |
| "status": "complete", |
| "skipped": "convert" if not condition.get("force_convert") else None, |
| "calibration": { |
| "corpus": str(corpus), |
| "samples": settings["samples"], |
| "max_tokens": settings["max_tokens"], |
| "output_block": settings["output_block"], |
| "damping": settings["damping"], |
| "raw_output": settings["raw_output"], |
| }, |
| "ppl": {}, |
| "finished": time.strftime("%Y-%m-%dT%H:%M:%S"), |
| "spec": str(self.spec_path), |
| } |
| if not self.dry_run: |
| (out / "result.json").write_text( |
| json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" |
| ) |
| return summary |
|
|
| int4 = self.work / f"int4-{self.lane}-{name}" |
| int4_eval = self.work / f"int4-{self.lane}-{name}-eval" |
| convert_command = [ |
| sys.executable, |
| str(self.scripts["convert"]), |
| "--load-from", |
| str(bf16), |
| "--output-dir", |
| str(int4), |
| ] |
| if not is_rtn: |
| convert_command += [ |
| "--preconditioners", |
| str(calib_npz), |
| "--calibration-json", |
| str(out / "calibration.json"), |
| ] |
| convert_settings = dict(self.spec.get("convert", {})) |
| convert_settings.update(condition.get("convert") or {}) |
| for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits", "symmetric_bits"): |
| if key in convert_settings: |
| convert_command += [f"--{key.replace('_', '-')}", str(convert_settings[key])] |
| if convert_settings.get("quantize_embedding"): |
| convert_command.append("--quantize-embedding") |
| if convert_settings.get("layer_filter"): |
| convert_command += ["--layer-filter", str(convert_settings["layer_filter"])] |
| if convert_settings.get("layer_bits_json"): |
| settings_path = self.resolve(convert_settings["layer_bits_json"]) |
| assert settings_path is not None |
| convert_command += ["--layer-bits-json", str(settings_path)] |
| if condition.get("layer_bits_json"): |
| bits_path = self.resolve(condition["layer_bits_json"]) |
| assert bits_path is not None |
| convert_command += ["--layer-bits-json", str(bits_path)] |
| self.run(f"{name} convert", convert_command, out / "lane.log") |
| self.run( |
| f"{name} eval copy", |
| [sys.executable, str(self.scripts["copy"]), "--source", str(int4), "--dest", str(int4_eval)], |
| out / "lane.log", |
| ) |
|
|
| summary = self.evaluate(name, int4_eval, bf16) |
| summary["status"] = "complete" |
| summary["env"] = self.env_provenance() |
| summary["eval_dtype"] = self.eval_dtype |
| summary["finished"] = time.strftime("%Y-%m-%dT%H:%M:%S") |
| summary["spec"] = str(self.spec_path) |
| if not self.dry_run: |
| (out / "result.json").write_text( |
| json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" |
| ) |
|
|
| if not self.dry_run: |
| shutil.rmtree(int4, ignore_errors=True) |
| shutil.rmtree(int4_eval, ignore_errors=True) |
| calib_npz.unlink(missing_ok=True) |
| return summary |
|
|
| def run_merge(self, bf16: Path) -> list[dict[str, Any]]: |
| merge = self.spec.get("merge") |
| if not merge: |
| return [] |
| en_raw = self.lane_dir / merge["en"] / "calibration.npz" |
| ja_raw = self.lane_dir / merge["ja"] / "calibration.npz" |
| summaries = [] |
| for ratio in merge.get("ratios", [0.5]): |
| label = f"{float(ratio) * 100:.0f}" if float(ratio) <= 1 else str(ratio) |
| name = merge.get("name_template", "balanced-{ratio}").format(ratio=label) |
| out = self.lane_dir / name |
| if not self.dry_run: |
| out.mkdir(parents=True, exist_ok=True) |
| existing = self.existing_result(name) |
| if existing is not None: |
| print(f"skip {name}: result.json already complete", flush=True) |
| summaries.append(existing) |
| continue |
| merged = out / "calibration.npz" |
| self.run( |
| f"{name} merge", |
| [ |
| sys.executable, |
| str(self.scripts["merge"]), |
| "--en", |
| str(en_raw), |
| "--ja", |
| str(ja_raw), |
| "--ja-ratio", |
| str(ratio), |
| "--damping", |
| str(merge.get("damping", 1e-3)), |
| "--output", |
| str(merged), |
| "--json-out", |
| str(out / "calibration.json"), |
| "--en-json", |
| str(self.lane_dir / merge["en"] / "calibration.json"), |
| "--ja-json", |
| str(self.lane_dir / merge["ja"] / "calibration.json"), |
| ], |
| out / "lane.log", |
| ) |
| int4 = self.work / f"int4-{self.lane}-{name}" |
| int4_eval = self.work / f"int4-{self.lane}-{name}-eval" |
| convert_command = [ |
| sys.executable, |
| str(self.scripts["convert"]), |
| "--load-from", |
| str(bf16), |
| "--output-dir", |
| str(int4), |
| "--preconditioners", |
| str(merged), |
| "--calibration-json", |
| str(out / "calibration.json"), |
| ] |
| for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits", "symmetric_bits"): |
| if key in self.spec.get("convert", {}): |
| convert_command += [f"--{key.replace('_', '-')}", str(self.spec["convert"][key])] |
| if self.spec.get("convert", {}).get("quantize_embedding"): |
| convert_command.append("--quantize-embedding") |
| self.run(f"{name} convert", convert_command, out / "lane.log") |
| self.run( |
| f"{name} eval copy", |
| [sys.executable, str(self.scripts["copy"]), "--source", str(int4), "--dest", str(int4_eval)], |
| out / "lane.log", |
| ) |
| summary = self.evaluate(name, int4_eval, bf16) |
| summary["status"] = "complete" |
| summary["env"] = self.env_provenance() |
| summary["eval_dtype"] = self.eval_dtype |
| summary["ja_ratio"] = ratio |
| summary["finished"] = time.strftime("%Y-%m-%dT%H:%M:%S") |
| summary["spec"] = str(self.spec_path) |
| if not self.dry_run: |
| (out / "result.json").write_text( |
| json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" |
| ) |
| if not self.dry_run: |
| shutil.rmtree(int4, ignore_errors=True) |
| shutil.rmtree(int4_eval, ignore_errors=True) |
| merged.unlink(missing_ok=True) |
| summaries.append(summary) |
| return summaries |
|
|
| |
|
|
| def validate(self, summaries: list[dict[str, Any]]) -> list[str]: |
| problems = [] |
| expected_chunks = self.spec.get("eval", {}).get("max_sequences", DEFAULT_EVAL["max_sequences"]) |
| baseline: dict[str, float] = {} |
| for summary in summaries: |
| name = summary.get("name") |
| for lang, ppl in (summary.get("ppl") or {}).items(): |
| if ppl.get("chunks") != expected_chunks: |
| problems.append(f"{name}/{lang}: chunks={ppl.get('chunks')} (expected {expected_chunks})") |
| value = ppl.get("bf16_ppl") |
| if value is None: |
| problems.append(f"{name}/{lang}: missing bf16_ppl") |
| continue |
| if lang not in baseline: |
| baseline[lang] = float(value) |
| elif abs(baseline[lang] - float(value)) > 0.05: |
| problems.append( |
| f"{name}/{lang}: bf16_ppl drift {float(value):.2f} vs {baseline[lang]:.2f}" |
| ) |
| return problems |
|
|
| def write_manifest(self, summaries: list[dict[str, Any]], problems: list[str]) -> Path: |
| manifest = { |
| "preflight": self.preflight, |
| "lane": self.lane, |
| "spec": str(self.spec_path), |
| "model": self.spec.get("model"), |
| "eval": self.spec.get("eval"), |
| "env": self.env_provenance(), |
| "environment_fingerprint": fingerprint(), |
| "eval_dtype": self.eval_dtype, |
| "results": summaries, |
| "problems": problems, |
| "updated": time.strftime("%Y-%m-%dT%H:%M:%S"), |
| } |
| path = self.lane_dir / "manifest.json" |
| if self.dry_run: |
| print(json.dumps(manifest, indent=2, ensure_ascii=False)[:2000]) |
| return path |
| self.lane_dir.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
| return path |
|
|
| def upload(self, repo: str) -> None: |
| if self.dry_run: |
| print(f"[dry-run] would upload {self.lane_dir} to {repo}") |
| return |
| subprocess.run( |
| ["hf", "upload", repo, str(self.lane_dir), self.lane, "--repo-type", "dataset"], |
| check=False, |
| ) |
|
|
| def pull(self, repo: str) -> None: |
| """Restore finished conditions of this lane from the results repo. |
| |
| Kaggle wipes /kaggle/working between sessions, so without this a lane |
| that died on condition 4 restarted from condition 1 and paid for the |
| same calibration twice. |
| """ |
| if self.dry_run: |
| print(f"[dry-run] would pull {self.lane} from {repo}") |
| return |
| target = self.work / "out" |
| target.mkdir(parents=True, exist_ok=True) |
| subprocess.run( |
| [ |
| "hf", "download", repo, "--repo-type", "dataset", |
| "--include", f"{self.lane}/*", "--local-dir", str(target), |
| ], |
| check=False, |
| ) |
|
|
|
|
| def read_json(path: Path) -> dict[str, Any] | None: |
| if not path.exists(): |
| return None |
| try: |
| return json.loads(path.read_text(encoding="utf-8")) |
| except json.JSONDecodeError: |
| return None |
|
|
|
|
| def run_conditions(runner, conditions, bf16, after_each=None, fail_fast: bool = False): |
| """Run every condition even if one dies; return (summaries, failures). |
| |
| A single OOM condition used to abort the lane, so the four conditions after |
| it never ran and nothing was uploaded. Failures are recorded instead. |
| """ |
| summaries = [] |
| failures = [] |
| for condition in conditions: |
| name = condition.get("name", "?") |
| try: |
| summaries.append(runner.run_condition(condition, bf16)) |
| except (SystemExit, Exception) as error: |
| failures.append(f"{name}: {error}") |
| print(f"CONDITION FAILED {name}: {error}", flush=True) |
| summaries.append({"name": name, "status": "failed", "error": str(error)}) |
| if fail_fast: |
| raise |
| if after_each is not None: |
| after_each() |
| return summaries, failures |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--spec", type=Path, required=True) |
| parser.add_argument("--dry-run", action="store_true") |
| parser.add_argument("--hf-results", default=None, help="upload <lane_dir> to this HF dataset repo") |
| parser.add_argument( |
| "--fail-fast", |
| action="store_true", |
| help="stop at the first failing condition instead of recording it and continuing", |
| ) |
| parser.add_argument("--skip-merge", action="store_true") |
| parser.add_argument("--work", default=None, help="override spec.paths.work") |
| parser.add_argument("--jax-platform", choices=("cpu", "gpu"), default=None, help="override spec.paths.jax_platform") |
| parser.add_argument("--eval-dtype", choices=("bfloat16", "float32"), default=None, help="override the eval model dtype") |
| parser.add_argument("--parallel", choices=("tensor", "replicated"), default=None, help="override convert/calibration sharding") |
| parser.add_argument( |
| "--shard", |
| default=None, |
| help="run only part of the condition list, e.g. 0/3. Merges are not allowed with sharding.", |
| ) |
| parser.add_argument( |
| "--exclude", |
| action="append", |
| default=[], |
| metavar="SUBSTR", |
| help="drop conditions whose name contains SUBSTR (repeatable); e.g. --exclude q512", |
| ) |
| args = parser.parse_args() |
|
|
| spec = json.loads(args.spec.read_text(encoding="utf-8")) |
| conditions = spec.get("conditions", []) |
| if not conditions and not spec.get("merge"): |
| raise SystemExit("spec has no conditions") |
|
|
| if args.exclude: |
| before = len(conditions) |
| conditions = [ |
| condition |
| for condition in conditions |
| if not any(pattern in condition.get("name", "") for pattern in args.exclude) |
| ] |
| print(f"excluded {before - len(conditions)} conditions matching {args.exclude}", flush=True) |
| if not conditions: |
| raise SystemExit(f"--exclude {args.exclude} removed every condition") |
| spec["conditions"] = conditions |
|
|
| if args.shard: |
| if spec.get("merge"): |
| raise SystemExit("--shard cannot be combined with spec.merge") |
| try: |
| index_text, count_text = args.shard.split("/") |
| index, count = int(index_text), int(count_text) |
| except ValueError: |
| raise SystemExit("--shard must look like 0/3") |
| if count <= 0 or not 0 <= index < count: |
| raise SystemExit("--shard index out of range") |
| conditions = [condition for position, condition in enumerate(conditions) if position % count == index] |
| if not conditions: |
| raise SystemExit(f"shard {args.shard} has no conditions") |
| spec["conditions"] = conditions |
| spec["lane"] = f"{spec['lane']}-shard{index + 1}of{count}" |
|
|
| if args.jax_platform: |
| spec.setdefault("paths", {})["jax_platform"] = args.jax_platform |
| if args.eval_dtype: |
| spec.setdefault("eval", {})["dtype"] = args.eval_dtype |
| if args.parallel: |
| spec.setdefault("convert", {})["parallel"] = args.parallel |
|
|
| runner = Runner(spec, args.spec, dry_run=args.dry_run) |
| if args.work: |
| runner.work = Path(args.work).expanduser() |
| runner.lane_dir = runner.work / "out" / runner.lane |
| if not args.dry_run: |
| runner.lane_dir.mkdir(parents=True, exist_ok=True) |
|
|
| runner.preflight = runner.run_preflight() |
| bf16 = runner.ensure_bf16() |
| if args.hf_results and not args.dry_run: |
| runner.pull(args.hf_results) |
|
|
| def after_each() -> None: |
| |
| |
| if args.hf_results: |
| runner.upload(args.hf_results) |
|
|
| summaries, failures = run_conditions( |
| runner, conditions, bf16, after_each=after_each, fail_fast=args.fail_fast |
| ) |
| if not args.skip_merge: |
| summaries.extend(runner.run_merge(bf16)) |
|
|
| completed = [summary for summary in summaries if summary.get("status") == "complete"] |
| problems = [] if args.dry_run else runner.validate(completed) |
| problems.extend(failures) |
| manifest = runner.write_manifest(summaries, problems) |
| print(f"\nmanifest: {manifest}") |
| if args.hf_results: |
| runner.upload(args.hf_results) |
| if problems: |
| print("VALIDATION PROBLEMS:") |
| for problem in problems: |
| print(f" - {problem}") |
| raise SystemExit(1) |
|
|
| print("LANE COMPLETE", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
