#!/usr/bin/env python3 """Audit trained CIFAR-100 checkpoints with feature-spectrum hooks.""" from __future__ import annotations import argparse import csv import hashlib import json import math import platform import sys from collections import defaultdict from dataclasses import dataclass from datetime import UTC, datetime from pathlib import Path from typing import Any import numpy as np import torch from torch import Tensor, nn from torch.utils.data import DataLoader, Subset from torchvision import datasets, transforms PROJECT_ROOT = Path(__file__).resolve().parents[1] if str(PROJECT_ROOT) not in sys.path: sys.path.insert(0, str(PROJECT_ROOT)) from gmnet.models import create_gmnet from gmnet.models.gmnet import GmNetBlock, SmoothClippedSelfGate from gmnet.spectral import RadialPSDAccumulator, torch_fft_lowpass Row = dict[str, Any] OUTPUT_ROOT = Path("/tmp/gmnet_runs/e1_trained_features") DIRECTORY_NAMES = { "relu6_self": "relu6", "relu_self": "relu", "gelu_self": "gelu", "smooth_clipped_self": "smooth_static", "identity": "identity", "no_gate": "no_gate", } GATE_ALIASES = { "relu6": "relu6_self", "relu": "relu_self", "gelu": "gelu_self", "smooth_static": "smooth_clipped_self", "smooth_clipped_static": "smooth_clipped_self", **{name: name for name in DIRECTORY_NAMES}, } LAYER_ORDER = ("input", "stage1", "stage2", "stage3", "stage4", "pre_classifier") def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--checkpoint-root", type=Path, default=Path("/tmp/gmnet_runs/e3_cifar100"), ) parser.add_argument( "--data-root", type=Path, default=Path("/tmp/gmnet_data/cifar-100") ) parser.add_argument("--output-dir", type=Path) parser.add_argument("--checkpoint-name", default="checkpoint_last.pt") parser.add_argument( "--gates", nargs="+", default=[ "relu6_self", "relu_self", "gelu_self", "smooth_clipped_self", "identity", "no_gate", ], ) parser.add_argument("--seeds", nargs="+", type=int, default=[0, 1, 2]) parser.add_argument("--device", default="cuda:0") parser.add_argument("--batch-size", type=int, default=256) parser.add_argument("--workers", type=int, default=4) parser.add_argument("--num-samples", type=int, default=10_000) parser.add_argument("--sample-seed", type=int, default=250322841) parser.add_argument( "--cutoffs", nargs="+", type=float, default=[0.0, 0.125, 0.25, 0.5, 0.75, 1.0] ) parser.add_argument("--butterworth-order", type=int, default=4) parser.add_argument("--high-low-split", type=float, default=0.5) parser.add_argument("--radial-bins", type=int, default=16) parser.add_argument("--allow-missing", action="store_true") parser.add_argument("--max-checkpoints", type=int) parser.add_argument("--require-epochs-completed", type=int) parser.add_argument( "--smoke", action="store_true", help="Use one available ETA checkpoint, 64 samples, and two cutoffs.", ) return parser.parse_args() def _canonical_gate(name: str) -> str: normalized = name.lower().replace("-", "_") if normalized not in GATE_ALIASES: raise ValueError(f"unknown gate {name!r}") return GATE_ALIASES[normalized] def _write_csv(path: Path, rows: list[Row]) -> None: if not rows: raise ValueError(f"refusing to write empty table: {path}") fields: list[str] = [] for row in rows: for field in row: if field not in fields: fields.append(field) with path.open("w", newline="", encoding="utf-8") as handle: writer = csv.DictWriter(handle, fieldnames=fields) writer.writeheader() writer.writerows(rows) def _mean_std(values: list[float]) -> tuple[float, float]: array = np.asarray(values, dtype=np.float64) return float(array.mean()), float(array.std(ddof=1)) if len(array) > 1 else 0.0 def _aggregate(rows: list[Row], keys: tuple[str, ...], metrics: tuple[str, ...]) -> list[Row]: groups: dict[tuple[Any, ...], list[Row]] = defaultdict(list) for row in rows: groups[tuple(row[key] for key in keys)].append(row) result: list[Row] = [] for key, group in sorted(groups.items()): output: Row = dict(zip(keys, key, strict=True)) output["count"] = len(group) for metric in metrics: observed = [float(row[metric]) for row in group if row.get(metric) is not None] finite = [value for value in observed if math.isfinite(value)] output[f"{metric}_finite_count"] = len(finite) output[f"{metric}_nonfinite_count"] = len(observed) - len(finite) output[f"{metric}_missing_count"] = len(group) - len(observed) if finite: output[f"{metric}_mean"], output[f"{metric}_std"] = _mean_std(finite) else: output[f"{metric}_mean"] = None output[f"{metric}_std"] = None result.append(output) return result @dataclass(frozen=True) class CheckpointSpec: gate: str seed: int path: Path def discover_checkpoints(args: argparse.Namespace) -> tuple[list[CheckpointSpec], list[str]]: requested_gates = [_canonical_gate(name) for name in args.gates] found: list[CheckpointSpec] = [] missing: list[str] = [] for gate in requested_gates: directory_name = DIRECTORY_NAMES[gate] for seed in args.seeds: path = ( args.checkpoint_root / f"e3_c100_s1_{directory_name}_seed{seed}" / args.checkpoint_name ) if path.is_file(): found.append(CheckpointSpec(gate, seed, path)) else: missing.append(str(path)) if missing and not args.allow_missing: preview = "\n".join(missing[:8]) raise FileNotFoundError( f"{len(missing)} requested checkpoints are missing; use --allow-missing for an ETA audit:\n{preview}" ) if args.max_checkpoints is not None: found = found[: args.max_checkpoints] if not found: raise FileNotFoundError(f"no checkpoints found under {args.checkpoint_root}") return found, missing def _load_model( spec: CheckpointSpec, device: torch.device, require_epochs_completed: int | None, ) -> tuple[nn.Module, dict[str, Any], Row]: checkpoint = torch.load(spec.path, map_location="cpu", weights_only=False) if not isinstance(checkpoint, dict) or "model" not in checkpoint or "config" not in checkpoint: raise ValueError(f"invalid checkpoint: {spec.path}") config = checkpoint["config"] checkpoint_seed = int(checkpoint.get("seed", -1)) if checkpoint_seed != spec.seed: raise ValueError( f"directory seed {spec.seed} disagrees with checkpoint seed {checkpoint_seed}: {spec.path}" ) epochs_completed = int(checkpoint.get("epoch", -1)) + 1 if ( require_epochs_completed is not None and epochs_completed != require_epochs_completed ): raise ValueError( f"checkpoint has {epochs_completed} completed epochs, expected exactly " f"{require_epochs_completed}: {spec.path}" ) model_config = dict(config["model"]) variant = str(model_config.pop("variant")) num_classes = int(model_config.pop("num_classes")) configured_gate = _canonical_gate(str(model_config.get("gate_type", "relu6_self"))) if configured_gate != spec.gate: raise ValueError( f"directory gate {spec.gate} disagrees with config gate {configured_gate}: {spec.path}" ) model = create_gmnet(variant, num_classes=num_classes, **model_config) incompatible = model.load_state_dict(checkpoint["model"], strict=True) if incompatible.missing_keys or incompatible.unexpected_keys: raise RuntimeError(f"state_dict mismatch for {spec.path}: {incompatible}") model.to(device).eval() manifest = { "gate": spec.gate, "seed": spec.seed, "run_name": checkpoint.get("run_name", spec.path.parent.name), "checkpoint": str(spec.path.resolve()), "checkpoint_name": spec.path.name, "checkpoint_epoch_zero_based": int(checkpoint.get("epoch", -1)), "checkpoint_epochs_completed": epochs_completed, "checkpoint_best_top1": float(checkpoint.get("best_top1", float("nan"))), } return model, config, manifest def _dataset_from_config(data_root: Path, config: dict[str, Any]) -> datasets.CIFAR100: data = config["data"] if str(data["dataset"]).lower() not in {"cifar100", "cifar-100"}: raise ValueError("trained feature audit only supports CIFAR-100") input_size = int(data.get("input_size", 32)) operations: list[Any] = [] if input_size != 32: operations.append(transforms.Resize((input_size, input_size))) operations.extend( [ transforms.ToTensor(), transforms.Normalize( tuple(data.get("mean", (0.5071, 0.4867, 0.4408))), tuple(data.get("std", (0.2675, 0.2565, 0.2761))), ), ] ) return datasets.CIFAR100( data_root, train=False, transform=transforms.Compose(operations), download=False ) class GateRegionAccumulator: """Count universal pre-gate regions and actual clipping crossings.""" def __init__(self, gate_module: nn.Module) -> None: self.gate_module = gate_module self.total = 0 self.negative = 0 self.active_reference = 0 self.above_reference = 0 self.actual_clip_crossing = 0 @property def clip_applies(self) -> bool: return isinstance(self.gate_module, SmoothClippedSelfGate) or getattr( self.gate_module, "name", None ) == "relu6_self" @property def clip_value_mean(self) -> float | None: if isinstance(self.gate_module, SmoothClippedSelfGate): return float(self.gate_module.clip_value.detach().mean().cpu()) if getattr(self.gate_module, "name", None) == "relu6_self": return 6.0 return None def update(self, value: Tensor) -> None: tensor = value.detach() self.total += tensor.numel() self.negative += int((tensor < 0).sum()) self.active_reference += int(((tensor >= 0) & (tensor < 6)).sum()) self.above_reference += int((tensor >= 6).sum()) if isinstance(self.gate_module, SmoothClippedSelfGate): self.actual_clip_crossing += int( (tensor >= self.gate_module.clip_value.detach()).sum() ) elif getattr(self.gate_module, "name", None) == "relu6_self": self.actual_clip_crossing += int((tensor >= 6).sum()) def compute(self) -> Row: if self.total == 0: raise RuntimeError("no gate inputs accumulated") return { "element_count": self.total, "negative_fraction": self.negative / self.total, "active_0_to_6_fraction": self.active_reference / self.total, "above_reference_6_fraction": self.above_reference / self.total, "clip_applies": self.clip_applies, "clip_value_mean": self.clip_value_mean, "actual_clip_crossing_fraction": ( self.actual_clip_crossing / self.total if self.clip_applies else None ), } def _block_gates(model: nn.Module) -> list[tuple[str, int, str, nn.Module]]: result: list[tuple[str, int, str, nn.Module]] = [] for stage_index, stage in enumerate(model.stages, start=1): block_index = 0 for module in stage: if isinstance(module, GmNetBlock): block_index += 1 result.append( (f"stage{stage_index}", stage_index, f"block{block_index}", module.gate) ) return result def _evaluate_cutoff( model: nn.Module, loader: DataLoader, device: torch.device, cutoff: float, *, butterworth_order: int, high_low_split: float, radial_bins: int, ) -> tuple[Row, list[Row], list[Row]]: feature_accumulators: dict[str, RadialPSDAccumulator] = { "input": RadialPSDAccumulator( high_low_split=high_low_split, radial_bins=radial_bins ) } gate_accumulators: dict[str, GateRegionAccumulator] = {} gate_metadata: dict[str, tuple[str, int, str]] = {} handles: list[Any] = [] def feature_hook(name: str): def hook(_module: nn.Module, _inputs: tuple[Tensor, ...], output: Tensor) -> None: accumulator = feature_accumulators.setdefault( name, RadialPSDAccumulator( high_low_split=high_low_split, radial_bins=radial_bins ), ) accumulator.update(output) return hook for stage_index, stage in enumerate(model.stages, start=1): handles.append(stage.register_forward_hook(feature_hook(f"stage{stage_index}"))) handles.append(model.norm.register_forward_hook(feature_hook("pre_classifier"))) for stage_name, stage_index, block_name, gate_module in _block_gates(model): key = f"{stage_name}.{block_name}" accumulator = GateRegionAccumulator(gate_module) gate_accumulators[key] = accumulator gate_metadata[key] = (stage_name, stage_index, block_name) def gate_hook( _module: nn.Module, inputs: tuple[Tensor, ...], accumulator: GateRegionAccumulator = accumulator, ) -> None: accumulator.update(inputs[0]) handles.append(gate_module.register_forward_pre_hook(gate_hook)) total = 0 top1 = 0 top5 = 0 try: with torch.inference_mode(): for images, targets in loader: images = images.to(device, non_blocking=device.type == "cuda") targets = targets.to(device, non_blocking=device.type == "cuda") filtered = torch_fft_lowpass( images, cutoff, order=butterworth_order ) feature_accumulators["input"].update(filtered) logits = model(filtered) predictions = logits.topk(5, dim=1).indices total += targets.numel() top1 += int((predictions[:, 0] == targets).sum()) top5 += int((predictions == targets[:, None]).any(dim=1).sum()) finally: for handle in handles: handle.remove() accuracy = { "cutoff": cutoff, "filter": "dc_only" if cutoff == 0 else "identity" if cutoff == 1 else "butterworth", "samples": total, "top1": 100.0 * top1 / total, "top5": 100.0 * top5 / total, } features = [ {"cutoff": cutoff, "layer": name, **feature_accumulators[name].compute().to_dict()} for name in LAYER_ORDER ] gates = [] for key, accumulator in gate_accumulators.items(): stage_name, stage_index, block_name = gate_metadata[key] gates.append( { "cutoff": cutoff, "layer": key, "stage": stage_name, "stage_index": stage_index, "block": block_name, **accumulator.compute(), } ) return accuracy, features, gates def _add_feature_transfer(rows: list[Row]) -> None: baseline = { (row["gate"], row["seed"], row["layer"]): row for row in rows if float(row["cutoff"]) == 1.0 } for row in rows: reference = baseline[(row["gate"], row["seed"], row["layer"])] if not row["valid"] or not reference["valid"]: row["centroid_delta_vs_identity"] = None row["high_low_log_ratio_vs_identity"] = None row["entropy_delta_vs_identity"] = None continue row["centroid_delta_vs_identity"] = ( row["spectral_centroid"] - reference["spectral_centroid"] ) if row["high_low_valid"] and reference["high_low_valid"]: epsilon = np.finfo(float).eps row["high_low_log_ratio_vs_identity"] = math.log( (row["high_low_ratio"] + epsilon) / (reference["high_low_ratio"] + epsilon) ) else: row["high_low_log_ratio_vs_identity"] = None row["entropy_delta_vs_identity"] = ( row["spectral_entropy"] - reference["spectral_entropy"] ) def _accuracy_auc(curve_rows: list[Row]) -> list[Row]: groups: dict[tuple[str, int], list[Row]] = defaultdict(list) for row in curve_rows: groups[(row["gate"], row["seed"])].append(row) result: list[Row] = [] for (gate, seed), rows in sorted(groups.items()): rows = sorted(rows, key=lambda row: float(row["cutoff"])) x = np.asarray([row["cutoff"] for row in rows], dtype=np.float64) if x[0] != 0.0 or x[-1] != 1.0: raise ValueError("accuracy AUC requires cutoff endpoints 0 and 1") top1 = np.asarray([row["top1"] for row in rows], dtype=np.float64) top5 = np.asarray([row["top5"] for row in rows], dtype=np.float64) result.append( { "gate": gate, "seed": seed, "frequency_accuracy_auc_top1": float(np.trapezoid(top1, x)), "frequency_accuracy_auc_top5": float(np.trapezoid(top5, x)), "identity_top1": float(top1[-1]), "identity_top5": float(top5[-1]), "dc_top1": float(top1[0]), "cutoff_count": len(x), } ) return result def _format(value: Any) -> str: if value is None: return "NA" return f"{float(value):.6g}" def _make_report( args: argparse.Namespace, manifest: list[Row], accuracy_summary: list[Row], auc_summary: list[Row], feature_summary: list[Row], gate_summary: list[Row], missing: list[str], sample_hash: str, ) -> str: partial = args.smoke or bool(missing) or any( row["checkpoint_epochs_completed"] < 100 for row in manifest ) if partial: status = "ETA checkpoint smoke; not a final comparison" elif len(manifest) == 18: status = "complete formal checkpoint matrix" else: status = "complete requested checkpoint subset; formal merge pending" lines = [ "# E1 Trained CIFAR-100 Feature Audit", "", f"Status: {status}.", "", "## Protocol", "", f"- Fixed test subset hash: `{sample_hash}`", f"- Samples per checkpoint/cutoff: {accuracy_summary[0]['samples_mean']:.0f}", f"- Checkpoint policy: `{args.checkpoint_name}` at fixed epoch {args.require_epochs_completed or 'recorded in manifest'}; checkpoint_best.pt is not used for model selection.", f"- Butterworth order: {args.butterworth_order}; cutoffs: {sorted(set(row['cutoff'] for row in accuracy_summary))}", "- Feature PSD is spatially centered and measured after each stage and after final norm.", "- Universal gate regions are x<0, 0<=x<6, and x>=6; actual clip crossing is only defined for ReLU6 and smooth-clipped gates.", "", "## Checkpoints", "", "| Gate | Seed | Epochs completed | Stored best Top-1 | Measured identity Top-1 |", "|---|---:|---:|---:|---:|", ] measured = { (row["gate"], row["seed"]): row for row in accuracy_summary if float(row["cutoff"]) == 1.0 } for row in manifest: accuracy = measured[(row["gate"], row["seed"])] lines.append( f"| {row['gate']} | {row['seed']} | {row['checkpoint_epochs_completed']} | " f"{_format(row['checkpoint_best_top1'])} | {_format(accuracy['top1_mean'])} |" ) lines.extend( [ "", "## Frequency-Accuracy AUC", "", "| Gate | Seeds | Identity Top-1 | Top-1 AUC |", "|---|---:|---:|---:|", ] ) for row in auc_summary: lines.append( f"| {row['gate']} | {row['count']} | {_format(row['identity_top1_mean'])} +/- {_format(row['identity_top1_std'])} | " f"{_format(row['frequency_accuracy_auc_top1_mean'])} +/- {_format(row['frequency_accuracy_auc_top1_std'])} |" ) lines.extend( [ "", "## Identity-Input Feature Spectrum", "", "| Gate | Layer | Spatial size | Centroid | High/low | Entropy |", "|---|---|---|---:|---:|---:|", ] ) for row in feature_summary: lines.append( f"| {row['gate']} | {row['layer']} | {row['height']}x{row['width']} | " f"{_format(row['spectral_centroid_mean'])} | {_format(row['high_low_ratio_mean'])} | " f"{_format(row['spectral_entropy_mean'])} |" ) lines.extend( [ "", "## Pre-Gate Regions on Identity Input", "", "| Gate | Stage | Negative | Active [0,6) | Above 6 | Actual clip crossing |", "|---|---|---:|---:|---:|---:|", ] ) for row in gate_summary: lines.append( f"| {row['gate']} | {row['stage']} | {_format(row['negative_fraction_mean'])} | " f"{_format(row['active_0_to_6_fraction_mean'])} | {_format(row['above_reference_6_fraction_mean'])} | " f"{_format(row['actual_clip_crossing_fraction_mean'])} |" ) lines.extend( [ "", "## Interpretation Limits", "", "- CIFAR-100 S1 reaches 1x1 at stage4. Stage4 and pre_classifier are retained in the table but their spatial PSD fields are NA by definition.", "- AUC integrates classification accuracy over progressively less filtered normalized inputs. It is causal sensitivity to the filter protocol, not model function frequency.", "- Comparisons from an ETA checkpoint or incomplete seed matrix must not be used as final gate rankings.", "- Per-layer transfer deltas for every cutoff are in feature_metrics.csv; per-block gate statistics are in gate_regions.csv.", "", ] ) return "\n".join(lines) def main() -> None: args = parse_args() if args.smoke: args.allow_missing = True args.max_checkpoints = 1 args.num_samples = min(args.num_samples, 64) args.workers = 0 args.cutoffs = [0.0, 1.0] if args.output_dir is None: args.output_dir = OUTPUT_ROOT / "smoke_eta" output_dir = (args.output_dir or OUTPUT_ROOT).resolve() allowed_root = OUTPUT_ROOT.resolve() if output_dir != allowed_root and allowed_root not in output_dir.parents: raise ValueError(f"output must stay under {allowed_root}") output_dir.mkdir(parents=True, exist_ok=True) cutoffs = sorted(set(float(value) for value in args.cutoffs)) if not cutoffs or cutoffs[0] != 0.0 or cutoffs[-1] != 1.0: raise ValueError("cutoffs must include exact endpoints 0 and 1") if args.num_samples <= 0 or args.batch_size <= 0: raise ValueError("num-samples and batch-size must be positive") specs, missing = discover_checkpoints(args) requested_device = args.device if requested_device.startswith("cuda") and not torch.cuda.is_available(): device = torch.device("cpu") else: device = torch.device(requested_device) first_checkpoint = torch.load(specs[0].path, map_location="cpu", weights_only=False) dataset = _dataset_from_config(args.data_root, first_checkpoint["config"]) sample_count = min(args.num_samples, len(dataset)) generator = np.random.default_rng(args.sample_seed) indices = generator.choice(len(dataset), size=sample_count, replace=False).astype(np.int64) sample_hash = hashlib.sha256(indices.tobytes()).hexdigest() subset = Subset(dataset, indices.tolist()) loader = DataLoader( subset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=device.type == "cuda", persistent_workers=args.workers > 0, ) (output_dir / "sample_indices.json").write_text( json.dumps( { "dataset": "CIFAR-100 test", "dataset_size": len(dataset), "sample_seed": args.sample_seed, "sample_count": sample_count, "sha256_int64_ordered": sample_hash, "indices": indices.tolist(), }, indent=2, ) + "\n", encoding="utf-8", ) manifest_rows: list[Row] = [] accuracy_rows: list[Row] = [] feature_rows: list[Row] = [] gate_rows: list[Row] = [] normalization_reference = json.dumps(first_checkpoint["config"]["data"], sort_keys=True) for checkpoint_index, spec in enumerate(specs, start=1): model, config, manifest = _load_model( spec, device, args.require_epochs_completed ) if json.dumps(config["data"], sort_keys=True) != normalization_reference: raise ValueError(f"data config differs across checkpoints: {spec.path}") manifest_rows.append(manifest) print( f"[{checkpoint_index}/{len(specs)}] {manifest['run_name']} " f"epoch={manifest['checkpoint_epochs_completed']}" ) for cutoff in cutoffs: accuracy, features, gates = _evaluate_cutoff( model, loader, device, cutoff, butterworth_order=args.butterworth_order, high_low_split=args.high_low_split, radial_bins=args.radial_bins, ) common = { "gate": spec.gate, "seed": spec.seed, "run_name": manifest["run_name"], "checkpoint_epochs_completed": manifest["checkpoint_epochs_completed"], } accuracy_rows.append({**common, **accuracy}) feature_rows.extend({**common, **row} for row in features) gate_rows.extend({**common, **row} for row in gates) del model if device.type == "cuda": torch.cuda.empty_cache() _add_feature_transfer(feature_rows) auc_rows = _accuracy_auc(accuracy_rows) accuracy_summary = _aggregate( accuracy_rows, ("gate", "seed", "cutoff"), ("samples", "top1", "top5"), ) auc_summary = _aggregate( auc_rows, ("gate",), ( "frequency_accuracy_auc_top1", "frequency_accuracy_auc_top5", "identity_top1", "identity_top5", "dc_top1", ), ) feature_identity = [row for row in feature_rows if float(row["cutoff"]) == 1.0] feature_summary = _aggregate( feature_identity, ("gate", "layer", "height", "width"), ("spectral_centroid", "high_low_ratio", "spectral_entropy"), ) feature_summary.sort(key=lambda row: (row["gate"], LAYER_ORDER.index(row["layer"]))) gate_identity = [row for row in gate_rows if float(row["cutoff"]) == 1.0] gate_summary = _aggregate( gate_identity, ("gate", "stage"), ( "negative_fraction", "active_0_to_6_fraction", "above_reference_6_fraction", "actual_clip_crossing_fraction", ), ) _write_csv(output_dir / "checkpoint_manifest.csv", manifest_rows) _write_csv(output_dir / "accuracy_curve.csv", accuracy_rows) _write_csv(output_dir / "accuracy_auc.csv", auc_rows) _write_csv(output_dir / "feature_metrics.csv", feature_rows) _write_csv(output_dir / "gate_regions.csv", gate_rows) _write_csv(output_dir / "accuracy_summary.csv", accuracy_summary) _write_csv(output_dir / "feature_summary.csv", feature_summary) _write_csv(output_dir / "gate_summary.csv", gate_summary) results = { "schema_version": 1, "experiment_id": "E1-trained-cifar100-feature-audit", "timestamp_utc": datetime.now(UTC).isoformat(), "status": "smoke" if args.smoke else "full", "environment": { "python": sys.version, "platform": platform.platform(), "torch": torch.__version__, "requested_device": requested_device, "actual_device": str(device), "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, }, "protocol": { "checkpoint_root": str(args.checkpoint_root.resolve()), "checkpoint_name": args.checkpoint_name, "require_epochs_completed": args.require_epochs_completed, "data_root": str(args.data_root.resolve()), "sample_count": sample_count, "sample_seed": args.sample_seed, "sample_indices_sha256": sample_hash, "cutoffs": cutoffs, "butterworth_order": args.butterworth_order, "high_low_split": args.high_low_split, "radial_bins": args.radial_bins, }, "missing_requested_checkpoints": missing, "checkpoint_manifest": manifest_rows, "accuracy_auc": auc_rows, "accuracy_auc_summary": auc_summary, "feature_identity_summary": feature_summary, "gate_identity_summary": gate_summary, } (output_dir / "results.json").write_text( json.dumps(results, indent=2, allow_nan=False) + "\n", encoding="utf-8" ) report = _make_report( args, manifest_rows, accuracy_summary, auc_summary, feature_summary, gate_summary, missing, sample_hash, ) (output_dir / "REPORT.md").write_text(report, encoding="utf-8") print(f"E1 trained feature audit complete: {output_dir}") if __name__ == "__main__": main()