| """Measure resident two-question inference on a source-only development sample.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import gc |
| import importlib.metadata |
| import math |
| import os |
| import statistics |
| import time |
| from pathlib import Path |
|
|
| import recipe as core |
|
|
|
|
| def select(rows, count=90): |
| candidates = [row for row in rows if row["role"] == "development"] |
| ordered = sorted(candidates, key=lambda row: core.text_sha("bbeh-native-timing89:" + row["id"])) |
| core.require(len(ordered) >= 2, "Need a separate warmup and timed request") |
| count = min(count, len(ordered) - 1) |
| return ordered[:count], ordered[count] |
|
|
|
|
| def summarize(records): |
| values = sorted(row["elapsed_seconds"] for row in records) |
| core.require(values and all(math.isfinite(v) and v > 0 for v in values), "Invalid timed durations") |
|
|
| def quantile(q): |
| index = q * (len(values) - 1) |
| lo, hi = math.floor(index), math.ceil(index) |
| return values[lo] + (values[hi] - values[lo]) * (index - lo) |
|
|
| return { |
| "requests": len(values), |
| "mean_seconds": statistics.mean(values), |
| "median_seconds": statistics.median(values), |
| "p90_seconds": quantile(0.90), |
| "p95_seconds": quantile(0.95), |
| "reciprocal_mean_service_seconds": len(values) / sum(values), |
| "by_task": { |
| task: { |
| "n": sum(r["task"] == task for r in records), |
| "mean_seconds": statistics.mean(r["elapsed_seconds"] for r in records if r["task"] == task), |
| } |
| for task in sorted({r["task"] for r in records}) |
| }, |
| } |
|
|
|
|
| def measure(study, output, *, variant, device, resource_rate_usd_per_second=None, resource_rate_source=None): |
| study, output = Path(study), Path(output) |
| core.require(variant in ("base", "lora") and device in ("cuda", "cpu"), "Unsupported timing variant/device") |
| if resource_rate_usd_per_second is not None: |
| core.require( |
| math.isfinite(resource_rate_usd_per_second) and resource_rate_usd_per_second > 0 and resource_rate_source, |
| "Need an explicit priced resource and source", |
| ) |
| output.mkdir(parents=True, exist_ok=False) |
| os.environ.update(TORCH_COMPILE_DISABLE="1", TORCHDYNAMO_DISABLE="1", TOKENIZERS_PARALLELISM="false") |
| import laya.train as lt |
| import numpy as np |
| import torch |
|
|
| import bbeh_native as native |
|
|
| torch.set_num_threads(8) |
| plan, rows = core.checked_plan(study) |
| trained = core.read(study / "native/trained.json") |
| core.require(trained["plan_sha256"] == core.sha(study / "plan.json"), "Training plan changed") |
| sample, warmup = select(rows) |
| protocol = { |
| "rule": "First90 development IDs by SHA256('bbeh-native-timing89:'+id); nextID is separate warmup; all if fewer than91", |
| "ids": [row["id"] for row in sample], |
| "warmup_id": warmup["id"], |
| "request_sha256": {row["id"]: core.text_sha(row["request"]) for row in sample + [warmup]}, |
| "source_plan_sha256": plan["source_plan_sha256"], |
| "outcomes_read": False, |
| "policy_computation": "Signed quality advantage and expected USD; lambda0 is timing-only, not a selected policy", |
| } |
| core.write(output / "sample-protocol.json", protocol) |
| checkpoint = study / "native" / variant |
| verification_start = time.monotonic() |
| core.require( |
| native.checkpoint_files(checkpoint) == trained["checkpoints"][variant]["files_sha256"], "Checkpoint changed" |
| ) |
| verification_seconds = time.monotonic() - verification_start |
| load_start = time.monotonic() |
| model, tokenizer, saved = native.load_checkpoint_preserving(lt, checkpoint) |
| settings = plan["native"] |
| maximum, head = settings["max_len"], settings["head_max_len"] |
| core.require(saved["max_len"] == maximum and saved["head_max_len"] == head, "Export context differs") |
| model.encoder.config.reference_compile = False |
| execution_device = torch.device(device) |
| model.to(execution_device).eval() |
| core.require({str(p.dtype) for p in model.parameters()} == {"torch.float32"}, "Expected FP32 resident inference") |
| if device == "cuda": |
| torch.cuda.synchronize() |
| load_seconds = time.monotonic() - load_start |
|
|
| def timed(row): |
| if device == "cuda": |
| torch.cuda.synchronize() |
| started = time.perf_counter() |
| items = native.encode_rows(lt, tokenizer, [row], plan["pair"], settings) |
| values = lt.calibration_records(model, tokenizer, items, execution_device, maximum, head, batch_size=2) |
| margins = native.margins_from_records(values, np.zeros((1, 2))) |
| probabilities = np.exp(-np.logaddexp(0, -margins)) |
| expected = core.expected_usd(probabilities, trained["conditional_cost_usd"]) |
| decision = bool(probabilities[0, 1] - probabilities[0, 0] >= 0) |
| if device == "cuda": |
| torch.cuda.synchronize() |
| return { |
| "id": row["id"], |
| "task": row["task"], |
| "elapsed_seconds": time.perf_counter() - started, |
| "probabilities": probabilities[0].tolist(), |
| "expected_usd": expected[0].tolist(), |
| "timing_only_strong": decision, |
| "state_tokens": len(items[0]["state_ids"]), |
| } |
|
|
| first = timed(warmup) |
| if device == "cuda": |
| torch.cuda.reset_peak_memory_stats() |
| records = [timed(row) for row in sample] |
| summary = summarize(records) |
| report = { |
| "format": "bbeh-resident-native-timing-v1", |
| "variant": variant, |
| "device": device, |
| "plan_sha256": core.sha(study / "plan.json"), |
| "trained_sha256": core.sha(study / "native/trained.json"), |
| "benchmark_sha256": core.sha(__file__), |
| "sample_protocol_sha256": core.sha(output / "sample-protocol.json"), |
| "checkpoint_verification_seconds": verification_seconds, |
| "model_load_seconds": load_seconds, |
| "warmup": first, |
| "records": records, |
| "summary": summary, |
| "native_context": settings, |
| "runtime_versions": {name: importlib.metadata.version(name) for name in settings["versions"]}, |
| "cpu_threads": torch.get_num_threads(), |
| "gpu": torch.cuda.get_device_name(0) if device == "cuda" else None, |
| "timing_includes": "Tokenization/full-context validation, both resident model questions, sigmoid probabilities and expected-cost/decision arithmetic", |
| "timing_excludes": "Checkpoint verification/loading, startup, warmup, artifact I/O, HTTP/network, queueing and idle capacity", |
| "limitations": "Sequential resident service measurements; reciprocal mean is not measured concurrent throughput", |
| "resource_rate_usd_per_second": resource_rate_usd_per_second, |
| "resource_rate_source": resource_rate_source, |
| "busy_resource_usd_per_10000": None |
| if resource_rate_usd_per_second is None |
| else summary["mean_seconds"] * 10000 * resource_rate_usd_per_second, |
| "cost_scope": "Timing-sample-based busy-resource projection only when a priced rate is supplied; not observed billing or full deployment cost", |
| } |
| if device == "cuda": |
| report.update( |
| peak_allocated_bytes=torch.cuda.max_memory_allocated(), peak_reserved_bytes=torch.cuda.max_memory_reserved() |
| ) |
| core.write(output / "report.json", report) |
| model, tokenizer = None, None |
| gc.collect() |
| if device == "cuda": |
| torch.cuda.empty_cache() |
| return report |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--study", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument("--variant", choices=("base", "lora"), required=True) |
| parser.add_argument("--device", choices=("cpu", "cuda"), required=True) |
| parser.add_argument("--resource-rate-usd-per-second", type=float) |
| parser.add_argument("--resource-rate-source") |
| args = parser.parse_args() |
| report = measure( |
| args.study, |
| args.output, |
| variant=args.variant, |
| device=args.device, |
| resource_rate_usd_per_second=args.resource_rate_usd_per_second, |
| resource_rate_source=args.resource_rate_source, |
| ) |
| print(report["summary"]) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
