Publish preregistered shared-miss attributes from frozen scalars only
This commit is contained in:
1 parent
d62b919e95
commit
44c1d5a10d
4 files changed
+4171
No files matched your search
@@ -0,0 +1,213 @@
|
||||
"""Use frozen scalar receipts for the registered common-miss description."""
|
||||
|
||||
from collections import defaultdict
|
||||
import csv
|
||||
import hashlib
|
||||
from io import StringIO
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
BASE = Path(__file__).resolve().parents[1]
|
||||
OUT = BASE / "artifacts/phase3-h2-shared-miss-attributes-2026-11-19"
|
||||
PREREG_COMMIT = "d62b919e95b9f774e3283b503aa699c23f86c104"
|
||||
SEED = 2026111408
|
||||
REPLICATES = 2000
|
||||
FILES = {
|
||||
"prereg": ("docs/moldastra-h2-shared-miss-attributes-prereg-2026-11-19.md",
|
||||
"d42c3a809234bed4e21287a08d4c405d37ee812b2e9cf23742df81652896879d"),
|
||||
"s2_tail": ("artifacts/phase2-h2-s2-tail-diagnostic-2026-11-18/output/result.json",
|
||||
"01b5c3de72ed708b2c4eb8ed1da6efe705aa1809ebd88621dfbbf7c932b25c7c"),
|
||||
"seed_comparison": ("artifacts/phase3-h2-family-diagnostic-2026-11-19/by-part.csv",
|
||||
"c6def5706acf8cf5b55ad5bd137e69665856b0f3bc254c639292366c58e195ec"),
|
||||
"pilot": ("artifacts/phase2-h2-pilot-2026-11-17/contract.json",
|
||||
"9f616974fb01f8f5cab6233273d541b3e53f5975f3632db45ab4676f911fba7b"),
|
||||
"v5_preparation": ("artifacts/gre24-reproduction-2026-11-15/v5-preparation-continuation-2026-11-16/complete.json",
|
||||
"8f3799fccfc61271d0c52194ff41838f644560024f8545fee17b72bd7597a15f"),
|
||||
}
|
||||
AVAILABLE = {
|
||||
"gate_count": "count",
|
||||
"volume_raw_cubed": "raw coordinate cubed",
|
||||
"Rg_raw": "raw coordinate",
|
||||
"tet_count": "count",
|
||||
"true_peak_node_count": "count",
|
||||
"true_peak_volume_fraction": "whole retained volume fraction",
|
||||
"true_peak_volume_raw_cubed": "raw coordinate cubed",
|
||||
"A_miss": "proportion",
|
||||
"A_field_relative_l2": "fraction",
|
||||
}
|
||||
UNAVAILABLE = {
|
||||
"physical_branch_count_and_length": "No independent branch or streamline annotations",
|
||||
"late_tail_component_count": "Frozen scalars omit the original per-node membership and induced tet edge graph",
|
||||
"late_tail_major_component_count": "Frozen scalars omit component masses",
|
||||
"late_tail_component_depth": "Frozen scalars omit per-node membership, edges and entrance sets",
|
||||
"late_tail_component_depth_mass_coverage": "Frozen scalars omit per-component membership and mass",
|
||||
"near_tie": "Major component peaks are unavailable from the frozen scalars",
|
||||
"major_component_peak_gap": "Major component peaks are unavailable from the frozen scalars",
|
||||
"physical_flow_length_to_wall_thickness": "No validated streamline length or general physical wall thickness",
|
||||
"L_tail_to_h_g": "No frozen retained-boundary area or true-tail geodesic moment",
|
||||
"L_tail_raw": "No frozen true-tail weighted full tet edge distance from independent gates",
|
||||
"L_tail_over_Rg": "No frozen true-tail weighted full tet edge distance from independent gates",
|
||||
"tail_unreachable_mass_fraction": "No frozen per-node reachability joined to true-tail membership",
|
||||
"surface_area_raw_squared": "No matching frozen retained-tet exterior boundary area scalar was located",
|
||||
"sqrt_lambda2_over_lambda1": "No matching frozen lumped-node covariance scalar was located",
|
||||
"sqrt_lambda3_over_lambda1": "No matching frozen lumped-node covariance scalar was located",
|
||||
"semantic_family_type": "No existing semantic type mapping covers the registered part support",
|
||||
}
|
||||
|
||||
|
||||
def checked_bytes(path, digest):
|
||||
raw = path.read_bytes()
|
||||
if hashlib.sha256(raw).hexdigest() != digest:
|
||||
raise ValueError(f"Frozen data changed: {path}")
|
||||
return raw
|
||||
|
||||
|
||||
def inputs():
|
||||
return {key: checked_bytes(BASE / path, digest) for key, (path, digest) in FILES.items()}
|
||||
|
||||
|
||||
def unique_index(rows):
|
||||
by_case = {r["case"]: r for r in rows}
|
||||
if len(by_case) != len(rows):
|
||||
raise ValueError("Duplicate case identities")
|
||||
return by_case
|
||||
|
||||
|
||||
def typed_rows(raw):
|
||||
comparison = list(csv.DictReader(StringIO(raw["seed_comparison"].decode("utf-8"))))
|
||||
tail = unique_index(json.loads(raw["s2_tail"])["rows"])
|
||||
pilot = json.loads(raw["pilot"])
|
||||
receipts = unique_index(json.loads(raw["v5_preparation"])["records"])
|
||||
sources = {}
|
||||
out = []
|
||||
for row in comparison:
|
||||
case = row["case"]
|
||||
component, fold = row["component_id"], int(row["fold"])
|
||||
r = tail[case]
|
||||
if (component, fold) != (r["component_id"], r["fold"]) or component != pilot["parts"][case]["clock_group"]:
|
||||
raise ValueError(f"Group or fold differs: {case}")
|
||||
if row["constant_truth"] != "False" or r["truth_tail"]["constant_field"]:
|
||||
raise ValueError(f"Unexpected constant reference tail: {case}")
|
||||
a = r["arms"]["A"]["full"]
|
||||
if float(row["A.d_tail_over_Rg"]) != a["d_tail_over_Rg"]:
|
||||
raise ValueError(f"A tail scalar changed: {case}")
|
||||
rng = r["Rg"]
|
||||
if rng != pilot["geometry"][case]["Rg"] or a["true_peak_volume"] is None:
|
||||
raise ValueError(f"Frozen geometry/peak identity differs: {case}")
|
||||
|
||||
record = receipts[case]
|
||||
target = pilot["parts"][case]
|
||||
path = BASE / record["result_path"]
|
||||
if path.resolve() != (BASE / target["output"] / "result.json").resolve():
|
||||
raise ValueError(f"Preparation result identity differs: {case}")
|
||||
prepared = json.loads(checked_bytes(path, record["result_sha256"]))
|
||||
sources[case] = dict(path=str(path), sha256=record["result_sha256"])
|
||||
if (prepared["status"] != "PASS" or prepared["case"] != case
|
||||
or prepared["output_sha256"] != target["output_sha256"]):
|
||||
raise ValueError(f"Frozen preparation differs: {case}")
|
||||
geometry, features = prepared["geometry"], prepared["features"]
|
||||
config = geometry.get("inlet_config", {})
|
||||
inlet = config.get("inlet_location", [])
|
||||
gate_ids = features.get("gate_raw_ids", [])
|
||||
gate_known = (geometry.get("gate_source", "").startswith("YAML inlet_location")
|
||||
and np.shape(inlet) == (3,) and np.isfinite(inlet).all() and len(gate_ids) >= 1)
|
||||
tets = geometry["raw_cell_types"]["10"]
|
||||
volume = features["volume"]
|
||||
if not (geometry["tet_nodes"] == a["nodes"] == r["nodes"] and tets > 0 and volume > 0
|
||||
and np.isfinite(volume) and 0 < a["true_peak_volume"] <= 1):
|
||||
raise ValueError(f"Invalid fixed retained-domain scalars: {case}")
|
||||
values = dict(
|
||||
gate_count=1 if gate_known else None, volume_raw_cubed=volume, Rg_raw=rng, tet_count=tets,
|
||||
true_peak_node_count=a["true_peak_count"], true_peak_volume_fraction=a["true_peak_volume"],
|
||||
true_peak_volume_raw_cubed=a["true_peak_volume"] * volume,
|
||||
A_miss=int(a["d_tail_over_Rg"] > .10), A_field_relative_l2=float(row["A.relative_l2"]))
|
||||
values.update(dict.fromkeys(UNAVAILABLE))
|
||||
out.append(dict(case=case, component_id=component, fold=fold,
|
||||
shared_miss=all(float(row[f"{s}.d_tail_over_Rg"]) > .10 for s in ("seed0", "seed1")),
|
||||
gate_inlet_xyz=inlet if gate_known else None,
|
||||
gate_mapping_raw_ids=gate_ids if gate_known else None,
|
||||
gate_source=geometry.get("gate_source") if gate_known else None, **values))
|
||||
if len(out) != 552 or len(unique_index(out)) != 552 or len({r["component_id"] for r in out}) != 204:
|
||||
raise ValueError("Registered support changed")
|
||||
if sum(r["shared_miss"] for r in out) != 34:
|
||||
raise ValueError("Registered grouping changed")
|
||||
return out, sources
|
||||
|
||||
|
||||
def grouped(rows):
|
||||
out = defaultdict(list)
|
||||
for r in rows:
|
||||
out[r["component_id"]].append(r)
|
||||
return out
|
||||
|
||||
|
||||
def attribute_rows(family_ids, groups, metric):
|
||||
expected = grouped(groups)
|
||||
valid = grouped([r for r in groups if r[metric] is not None])
|
||||
member_means = {key: np.mean([r[metric] for r in members]) for key, members in valid.items()}
|
||||
array = np.array([member_means.get(key, np.nan) for key in family_ids], dtype=np.float64)
|
||||
series = array[np.isfinite(array)]
|
||||
available_mass = sum(r["volume_raw_cubed"] for members in valid.values() for r in members)
|
||||
total_mass = sum(r["volume_raw_cubed"] for r in groups)
|
||||
detail = dict(expected_parts=len(groups), expected_families=len(expected),
|
||||
available_parts=sum(map(len, valid.values())), available_families=len(valid),
|
||||
missing_parts=len(groups)-sum(map(len, valid.values())),
|
||||
families_all_missing=len(set(expected)-set(valid)),
|
||||
available_mesh_mass_fraction=available_mass/total_mass,
|
||||
family_equal_mean=float(series.mean()) if len(series) else None,
|
||||
quartiles=np.quantile(series, [.25, .5, .75]).tolist() if len(series) else None)
|
||||
return array, detail
|
||||
|
||||
|
||||
def sample_means(values, draws):
|
||||
samples = values[draws]
|
||||
counts = np.sum(np.isfinite(samples), axis=1)
|
||||
return np.divide(np.nansum(samples, axis=1), counts, where=counts > 0,
|
||||
out=np.full(len(samples), np.nan))
|
||||
|
||||
|
||||
def comparisons(rows):
|
||||
families = sorted(grouped(rows))
|
||||
miss = [r for r in rows if r["shared_miss"]]
|
||||
other = [r for r in rows if not r["shared_miss"]]
|
||||
# The same complete-family draw is used for both groups and all properties.
|
||||
draws = np.random.default_rng(SEED).integers(len(families), size=(REPLICATES, len(families)))
|
||||
results = {}
|
||||
for metric in (*AVAILABLE, *UNAVAILABLE):
|
||||
x, shared = attribute_rows(families, miss, metric)
|
||||
y, control = attribute_rows(families, other, metric)
|
||||
_, all_parts = attribute_rows(families, rows, metric)
|
||||
diff = sample_means(x, draws) - sample_means(y, draws)
|
||||
observed = diff[np.isfinite(diff)]
|
||||
left, right = shared["family_equal_mean"], control["family_equal_mean"]
|
||||
results[metric] = dict(units=AVAILABLE.get(metric), unavailable_reason=UNAVAILABLE.get(metric),
|
||||
all_parts=all_parts, shared_miss=shared, other=control,
|
||||
effect=left-right if left is not None and right is not None else None,
|
||||
interval_95=np.quantile(observed, [.025, .975]).tolist() if len(observed) else None,
|
||||
undefined_replicates=REPLICATES-len(observed))
|
||||
return results
|
||||
|
||||
|
||||
def main():
|
||||
if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
|
||||
raise RuntimeError("Use an empty CUDA device mask for this CPU-only description")
|
||||
data = inputs()
|
||||
rows, sources = typed_rows(data)
|
||||
metrics = comparisons(rows)
|
||||
result = dict(prereg_commit=PREREG_COMMIT, inputs=FILES, per_case_preparation_sources=sources,
|
||||
bootstrap=dict(replicates=REPLICATES, seed=SEED, unit="original family, common draw"),
|
||||
metrics=metrics, gpu_seconds=0, target_arrays_read=0, full_geometry_arrays_read=0,
|
||||
prediction_arrays_read=0, raw_targets_decoded=0, new_fits=0)
|
||||
OUT.mkdir(exist_ok=False)
|
||||
(OUT / "result.json").write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
|
||||
with (OUT / "by-part.jsonl").open("x") as stream:
|
||||
for r in rows:
|
||||
stream.write(json.dumps(r, ensure_ascii=False, allow_nan=False) + "\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in new issue
Block a user