| from __future__ import annotations |
|
|
| import csv |
| import json |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def csv_count(path: Path) -> tuple[int, set[str]]: |
| with path.open("r", encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| return len(rows), set(rows[0]) if rows else set() |
|
|
|
|
| def verify(config: dict[str, Any], results_dir: Path) -> dict[str, Any]: |
| failures = [] |
| expected_runs = len(config["prompts"]) * int(config["campaign"]["replicates"]) * len(config["formats"]) |
| expected_per_format = len(config["prompts"]) * int(config["campaign"]["replicates"]) |
| expected_noise_groups = len(config["prompts"]) * int(config["campaign"]["replicates"]) |
| expected_trajectory_rows = (len(config["formats"]) - 1) * expected_per_format * int(config["controls"]["steps"]) * 2 |
| expected_weight_rows = (len(config["formats"]) - 1) * 430 |
|
|
| def require(condition: bool, message: str) -> None: |
| if not condition: |
| failures.append(message) |
|
|
| manifest = json.loads((results_dir / "manifest.json").read_text(encoding="utf-8")) |
| require(manifest["config_sha256"] == config["_config_sha256"], "Manifest configuration hash differs from current configuration") |
| for name, expected in config["integrity"]["expected_sha256"].items(): |
| model = manifest["models"].get(name, {}) |
| require(model.get("sha256") == expected, f"Publisher hash mismatch or missing hash for {name}") |
| require(model.get("publisher_hash_match") is True, f"Publisher match flag is not true for {name}") |
|
|
| for name in ("preflight.json", "campaign_complete.json", "report_complete.json"): |
| require((results_dir / name).is_file(), f"Missing completion marker {name}") |
| require(json.loads((results_dir / "preflight.json").read_text(encoding="utf-8"))["passed"] is True, "Preflight marker is not passed") |
| require(json.loads((results_dir / "campaign_complete.json").read_text(encoding="utf-8"))["scored_runs"] == expected_runs, f"Campaign marker does not declare {expected_runs} runs") |
| if config.get("_base_results_dir"): |
| require((results_dir / "extension_import.json").is_file(), "Extension import marker is missing") |
| require((results_dir / "metrics" / "performance_bridge.json").is_file(), "Performance bridge evidence is missing") |
|
|
| matrix = json.loads((results_dir / "run_matrix.json").read_text(encoding="utf-8")) |
| require(len(matrix) == expected_runs, f"Run matrix has {len(matrix)} rows instead of {expected_runs}") |
| require(len({row["run_id"] for row in matrix}) == expected_runs, "Run matrix contains duplicate run ids") |
| counts = Counter(row["format_id"] for row in matrix) |
| require(all(counts[format_id] == expected_per_format for format_id in config["formats"]), f"Format counts are wrong: {dict(counts)}") |
|
|
| noise_groups = defaultdict(list) |
| for row in matrix: |
| directory = results_dir / "captures" / row["run_id"] |
| required_files = ["metadata.json", "image.png", "decoded_float32.npy", "final_latent_float32.npy", "trajectory.npz"] |
| require(all((directory / name).is_file() for name in required_files), f"Incomplete capture: {row['run_id']}") |
| if (directory / "metadata.json").is_file(): |
| metadata = json.loads((directory / "metadata.json").read_text(encoding="utf-8")) |
| require({"sampling", "vae_decode", "output"}.issubset(metadata), f"Metadata sections missing: {row['run_id']}") |
| noise_groups[(row["prompt_id"], row["replicate"])].append(metadata["sampling"]["noise_sha256"]) |
| require(len(noise_groups) == expected_noise_groups, f"Expected {expected_noise_groups} prompt-seed noise groups, found {len(noise_groups)}") |
| for key, values in noise_groups.items(): |
| require(len(values) == len(config["formats"]) and len(set(values)) == 1, f"Noise mismatch for {key}: {values}") |
|
|
| for format_id in config["formats"]: |
| hashes = [] |
| for repeat in range(3): |
| metadata_path = results_dir / "captures" / f"repeatability__{format_id}__{repeat}" / "metadata.json" |
| require(metadata_path.is_file(), f"Missing repeatability result {format_id}/{repeat}") |
| if metadata_path.is_file(): |
| hashes.append(json.loads(metadata_path.read_text(encoding="utf-8"))["output"]["image_sha256"]) |
| require(len(hashes) == 3 and len(set(hashes)) == 1, f"Repeatability mismatch for {format_id}: {hashes}") |
|
|
| expected_tables = { |
| "image_core.csv": expected_runs, |
| "image_advanced.csv": expected_runs, |
| "latency_components.csv": expected_runs, |
| "performance_runs.csv": expected_runs, |
| "trajectory.csv": expected_trajectory_rows, |
| "weight_parameters_all.csv": expected_weight_rows, |
| } |
| for name, expected_count in expected_tables.items(): |
| path = results_dir / "metrics" / name |
| require(path.is_file(), f"Missing metric table {name}") |
| if path.is_file(): |
| count, _ = csv_count(path) |
| require(count == expected_count, f"Metric table {name} has {count} rows, expected {expected_count}") |
|
|
| advanced_count, advanced_fields = csv_count(results_dir / "metrics" / "image_advanced.csv") |
| required_advanced = { |
| "lpips_alex", |
| "lpips_vgg", |
| "dists", |
| "ms_ssim", |
| "dinov2_large_image_cosine_to_bf16", |
| "openclip_vith14_prompt_score", |
| "pickscore_v1", |
| "hpsv2_1", |
| "pyiqa_musiq", |
| "pyiqa_maniqa", |
| "pyiqa_topiq_nr", |
| "pyiqa_niqe", |
| "pyiqa_brisque", |
| "ocr_expected_phrase_exact_fraction", |
| } |
| require(required_advanced.issubset(advanced_fields), f"Advanced metric columns missing: {sorted(required_advanced - advanced_fields)}") |
|
|
| for folder in ("full", "differences", "details"): |
| count = len(list((results_dir / "comparison_sheets" / folder).glob("*.png"))) |
| require(count == 30, f"Comparison sheet folder {folder} has {count} PNGs instead of 30") |
| require((results_dir / "comparison_sheets" / "contact_sheet_replicate0.png").is_file(), "Master contact sheet is missing") |
|
|
| for format_id in config["formats"]: |
| require((results_dir / "telemetry" / f"{format_id}.csv").is_file(), f"GPU telemetry missing for {format_id}") |
| require((results_dir / "telemetry" / f"system_{format_id}.csv").is_file(), f"System telemetry missing for {format_id}") |
|
|
| equivalence_path = results_dir / "validation" / "sampler_equivalence.json" |
| require(equivalence_path.is_file(), "Sampler equivalence evidence is missing") |
| if equivalence_path.is_file(): |
| equivalence = json.loads(equivalence_path.read_text(encoding="utf-8")) |
| require(equivalence["latent_bit_exact"] and equivalence["image_bit_exact"], "Custom sampler is not bit-exact with standard KSampler") |
| require(equivalence["latent_max_abs"] == 0.0 and equivalence["image_max_abs"] == 0.0, "Sampler equivalence has nonzero error") |
|
|
| scored_errors = [] |
| with (results_dir / "runs.jsonl").open("r", encoding="utf-8") as stream: |
| for line in stream: |
| row = json.loads(line) |
| if row.get("scored") and row.get("status") == "error": |
| scored_errors.append(row["run_id"]) |
| require(not scored_errors, f"Scored run ledger contains errors: {scored_errors}") |
|
|
| report_path = results_dir / "TECHNICAL_REPORT.md" |
| require(report_path.is_file(), "Technical report is missing") |
| if report_path.is_file(): |
| report = report_path.read_text(encoding="utf-8") |
| for phrase in ("Best quantized BF16 fidelity", "INT8 ConvRot", "INT4 ConvRot", "GGUF Q8_0", "GGUF Q4_K_M", "OCR on prompts", "bit-identical", "Primary sources"): |
| require(phrase in report, f"Technical report is missing required section/claim: {phrase}") |
|
|
| workflows = [Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_api.json", Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_interactive.json"] |
| has_gguf = any(fmt.startswith("gguf") for fmt in config.get("formats", {})) |
| if has_gguf: |
| workflows.extend([ |
| Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_api_gguf.json", |
| Path(config["_config_path"]).parent / "workflows" / "krea2_benchmark_interactive_gguf.json" |
| ]) |
| for workflow in workflows: |
| require(workflow.is_file(), f"Workflow is missing: {workflow.name}") |
| if workflow.is_file(): |
| json.loads(workflow.read_text(encoding="utf-8")) |
|
|
| result = { |
| "passed": not failures, |
| "failures": failures, |
| "scored_runs": len(matrix), |
| "format_counts": dict(counts), |
| "noise_groups": len(noise_groups), |
| "metric_tables_checked": expected_tables, |
| "advanced_metric_columns_checked": sorted(required_advanced), |
| "comparison_sheet_groups": 30, |
| } |
| output_path = results_dir / "validation" / "completion_audit.json" |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
| output_path.write_text(json.dumps(result, indent=2, sort_keys=True), encoding="utf-8") |
| if failures: |
| raise RuntimeError("Completion audit failed:\n- " + "\n- ".join(failures)) |
| return result |
|
|
