Download unequal_speed_interface/verify_outputs.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 9.48 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/unequal_speed_interface/verify_outputs.py
- Command line
-
hf download hf://soundai2016/ADComp/unequal_speed_interface/verify_outputs.py
-
curl -L -o verify_outputs.py https://huggingface.co/soundai2016/ADComp/resolve/main/unequal_speed_interface/verify_outputs.py
9.48 kB
| """Independently validate the saved numerical outputs without CB solves.""" | |
| import csv | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| HERE = Path(__file__).resolve().parent | |
| OUT = HERE/"results" | |
| def norm(array): | |
| return float(np.linalg.norm(array)) | |
| def read_csv(name): | |
| return list(csv.DictReader((OUT/name).open())) | |
| def main(): | |
| config = json.loads((HERE/"config.json").read_text()) | |
| manifest = json.loads((OUT/"output_manifest.json").read_text()) | |
| mismatches = [] | |
| for family in ("source_hashes", "artifact_hashes"): | |
| for name, expected in manifest[family].items(): | |
| path = HERE/name | |
| if not path.exists() or hashlib.sha256(path.read_bytes()).hexdigest() != expected: | |
| mismatches.append(name) | |
| reference = np.load(OUT/"continuous_reference.npz") | |
| times, yf = reference["time"], reference["receiver_pressure"] | |
| config_hash = hashlib.sha256((HERE/"config.json").read_bytes()).hexdigest() | |
| rows = read_csv("summary.csv") | |
| records = json.loads((OUT/"summary.json").read_text())["rows"] | |
| expected_models = len(config["grids"])*(1+len(config["modes_per_patch"]))+len(config["rational_krylov_modes_per_patch"]) | |
| total_error_defects, local_error_defects, cosine_defects, per_source_defects = [], [], [], [] | |
| scalar_checks = [] | |
| for row, json_row in zip(rows, records): | |
| n, end = int(row["grid"]), int(row["time_end"]) | |
| active = times <= end+1e-12 | |
| full = np.load(OUT/f"n{n}_full_receiver.npz")["receiver_pressure"] | |
| if row["method"] == "full_separable": | |
| filename = OUT/f"n{n}_full.json" | |
| observed = full | |
| else: | |
| stem = f"n{n}_{row['method']}_m{int(row['modes_per_patch'])}" | |
| filename = OUT/f"{stem}.json" | |
| observed = np.load(OUT/f"{stem}.npz")["receiver_pressure"] | |
| stored = json.loads(filename.read_text()) | |
| scalar_checks.append(stored["config_sha256"] == config_hash) | |
| scalar_checks.append(int(json_row["grid"])==n and int(json_row["time_end"])==end and json_row["method"]==row["method"]) | |
| error = norm(observed[active]-yf[active])/norm(yf[active]) | |
| total_error_defects.extend((abs(error-float(row["receiver_total_error"])), | |
| abs(error-stored["receiver_total_error"][f"T{end}"]["relative_error"]), | |
| abs(error-json_row["receiver_total_error"]))) | |
| for s in range(3): | |
| per_source = norm(observed[active,:,s]-yf[active,:,s])/norm(yf[active,:,s]) | |
| per_source_defects.append(abs(per_source-stored["receiver_total_error"][f"T{end}"]["per_source"][s])) | |
| if row["method"] != "full_separable": | |
| er, eg = observed[active]-full[active], full[active]-yf[active] | |
| local_error = norm(er)/norm(full[active]) | |
| cosine = float(np.sum(er*eg)/max(norm(er)*norm(eg),1e-300)) | |
| local_error_defects.extend((abs(local_error-float(row["receiver_same_grid_error"])), | |
| abs(local_error-stored["receiver_same_grid_error"][f"T{end}"]["relative_error"]))) | |
| cosine_defects.extend((abs(cosine-float(row["receiver_error_vector_cosine"])), | |
| abs(cosine-stored["receiver_reduction_grid_error_cosine"][f"T{end}"]), | |
| abs(cosine-json_row["receiver_error_vector_cosine"]))) | |
| pairs = read_csv("modal_pairs.csv") | |
| modal_rows = json.loads((OUT/"modal_summary.json").read_text())["models"] | |
| fine = np.load(OUT/"continuous_catalogue.npz") | |
| coarse = np.load(OUT/f"n{config['modal_grid']}_full_spectrum.npz") | |
| decompositions = {} | |
| budget_defects, frequency_term_defects, counterfactual_defects, modal_stat_defects = [], [], [], [] | |
| match_counts = {} | |
| component_names = ("ritz_frequency", "grid_frequency", "source_coupling", "receiver_coupling", "unmatched") | |
| for row in modal_rows: | |
| name = row["model"] | |
| paired = [p for p in pairs if p["model"]==name] | |
| match_counts[name] = len(paired) | |
| scalar_checks.append(len(paired)==row["accepted_triples"]) | |
| ri = np.asarray([int(p["rom_mode"]) for p in paired]) | |
| ci = np.asarray([int(p["coarse_mode"]) for p in paired]) | |
| fi = np.asarray([int(p["continuous_mode"]) for p in paired]) | |
| raw = np.load(OUT/f"n{config['modal_grid']}_{name}.npz") | |
| data = dict(np.load(OUT/f"{name}_decomposition.npz")) | |
| decompositions[name] = data | |
| Hr = np.einsum("rj,js->jrs", raw["observation"][:,ri], raw["coefficients"][ri]) | |
| Hf = np.einsum("rj,js->jrs", fine["c"][:,fi], fine["b"][fi]) | |
| cos_r = np.cos(times[:,None]*raw["omega"][ri][None]) | |
| cos_h = np.cos(times[:,None]*coarse["omega"][ci][None]) | |
| cos_f = np.cos(times[:,None]*fine["omega"][fi][None]) | |
| ritz = np.einsum("tj,jrs->trs",cos_r-cos_h,Hr,optimize=True) | |
| grid = np.einsum("tj,jrs->trs",cos_h-cos_f,Hr,optimize=True) | |
| coupling = np.einsum("tj,jrs->trs",cos_f,Hr-Hf,optimize=True) | |
| frequency_term_defects.extend((norm(ritz-data["ritz_frequency"])/norm(yf), | |
| norm(grid-data["grid_frequency"])/norm(yf), | |
| norm(coupling-data["source_coupling"]-data["receiver_coupling"])/norm(yf))) | |
| error = data["rom_response"]-yf | |
| budget_defects.append(norm(error-sum(data[key] for key in component_names))/norm(error)) | |
| counterfactual_defects.extend((norm(data["no_ritz_frequency_response"]-(raw["receiver_pressure"]-ritz))/norm(yf), | |
| norm(data["continuous_frequency_response"]-(raw["receiver_pressure"]-ritz-grid))/norm(yf))) | |
| for key,array in (("total_error",error), | |
| ("coarse_frequency_replacement_error",data["no_ritz_frequency_response"]-yf), | |
| ("continuous_frequency_replacement_error",data["continuous_frequency_response"]-yf)): | |
| modal_stat_defects.append(abs(norm(array)/norm(yf)-row[key])) | |
| for key in component_names: | |
| modal_stat_defects.append(abs(norm(data[key])/norm(yf)-row[key+"_relative_norm"])) | |
| wg = np.linalg.norm(Hf,axis=(1,2)) | |
| wg /= wg.sum() | |
| dg = (coarse["omega"][ci]-fine["omega"][fi])/fine["omega"][fi] | |
| dr = (raw["omega"][ri]-coarse["omega"][ci])/fine["omega"][fi] | |
| modal_stat_defects.extend((abs(float(wg@dg)-row["weighted_relative_grid_shift"]), | |
| abs(float(wg@dr)-row["weighted_relative_ritz_shift"]))) | |
| gram_defects = [] | |
| for row in read_csv("modal_component_gram.csv"): | |
| d = decompositions[row["model"]] | |
| val = float(np.sum(d[row["component_a"]]*d[row["component_b"]])/norm(yf)**2) | |
| gram_defects.append(abs(val-float(row["normalized_inner_product"]))) | |
| windows = read_csv("receiver_time_windows.csv") | |
| window_defects = [] | |
| for row in windows: | |
| active = (times >= float(row["start"])-1e-12)&(times <= float(row["end"])+1e-12) | |
| r, s = int(row["receiver"])-1, int(row["source"])-1 | |
| data = decompositions[row["model"]] | |
| ref = yf[active,r,s] | |
| original = norm(data["rom_response"][active,r,s]-ref)/norm(ref) | |
| replaced = norm(data["no_ritz_frequency_response"][active,r,s]-ref)/norm(ref) | |
| window_defects.extend((abs(original-float(row["original_error"])), | |
| abs(replaced-float(row["coarse_replacement_error"])), | |
| abs(100*(replaced-original)-float(row["coarse_replacement_change_percentage_points"])))) | |
| report = { | |
| "scope": "Independent checks from receiver traces and modal factors; no CB basis rebuild and no rerun of large-grid pressure histories.", | |
| "expected_model_count":expected_models,"model_count":len(rows)//2, | |
| "summary_csv_rows":len(rows),"summary_json_rows":len(records), | |
| "modal_model_count":len(modal_rows),"matched_triples":match_counts, | |
| "receiver_window_rows":len(windows),"expected_receiver_window_rows":len(modal_rows)*8*12, | |
| "source_hashes_checked":len(manifest["source_hashes"]), | |
| "artifact_hashes_checked":len(manifest["artifact_hashes"]),"hash_mismatches":mismatches, | |
| "receiver_total_statistic_max_absolute_defect":max(total_error_defects,default=0.), | |
| "receiver_same_grid_statistic_max_absolute_defect":max(local_error_defects,default=0.), | |
| "receiver_per_source_statistic_max_absolute_defect":max(per_source_defects,default=0.), | |
| "window_error_cosine_max_absolute_defect":max(cosine_defects,default=0.), | |
| "modal_budget_max_relative_defect":max(budget_defects,default=0.), | |
| "frequency_terms_reconstructed_max_normalized_defect":max(frequency_term_defects,default=0.), | |
| "counterfactual_reconstructed_max_normalized_defect":max(counterfactual_defects,default=0.), | |
| "modal_statistics_max_absolute_defect":max(modal_stat_defects,default=0.), | |
| "component_gram_max_absolute_defect":max(gram_defects,default=0.), | |
| "receiver_window_statistics_max_absolute_defect":max(window_defects,default=0.), | |
| } | |
| defect_keys = [k for k in report if "defect" in k] | |
| report["passed"] = (not mismatches and all(scalar_checks) | |
| and len(rows)==len(records)==2*expected_models | |
| and len(windows)==report["expected_receiver_window_rows"] | |
| and all(report[k] < 2e-10 for k in defect_keys)) | |
| (OUT/"output_verification.json").write_text(json.dumps(report,indent=2,allow_nan=False)+"\n") | |
| print(json.dumps(report,indent=2)) | |
| if not report["passed"]: | |
| raise RuntimeError("Unequal-speed output verification failed") | |
| if __name__ == "__main__": | |
| main() | |