| |
| """Summarize the matched CIFAR-100 pre-gate for ImageNet protocol v2.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from scipy import stats |
|
|
|
|
| VARIANTS = { |
| "smooth_corrected": "e3_c100_pregate_v2_smooth_corrected_seed{seed}", |
| "relu6_only": "e3_c100_pregate_v2_relu6_only_seed{seed}", |
| } |
| METRICS = ( |
| "clean_top1", |
| "mean_corruption_top1", |
| "clean_nll", |
| "mean_corruption_nll", |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--reference-root", type=Path, default=Path("/tmp/gmnet_runs/e3_cifar100") |
| ) |
| parser.add_argument( |
| "--pregate-root", |
| type=Path, |
| default=Path("/tmp/gmnet_runs/e3_cifar100_pregate_v2"), |
| ) |
| parser.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("/nfs/ywang29/GmNet/local_results/imagenet_v2_pregate"), |
| ) |
| return parser.parse_args() |
|
|
|
|
| def load_result(path: Path) -> dict[str, Any]: |
| result = json.loads(path.read_text(encoding="utf-8")) |
| if result.get("partial_evaluation") or not result.get("complete_training_required"): |
| raise ValueError(f"incomplete evaluation cannot enter pre-gate: {path}") |
| values = [result["overall"][metric] for metric in METRICS] |
| if not np.isfinite(np.asarray(values, dtype=np.float64)).all(): |
| raise ValueError(f"non-finite result: {path}") |
| return result |
|
|
|
|
| def paired_interval(differences: np.ndarray) -> tuple[float, float]: |
| differences = np.asarray(differences, dtype=np.float64) |
| if differences.shape != (3,): |
| raise ValueError("pre-gate inference requires exactly three paired seeds") |
| radius = float(stats.t.ppf(0.975, 2) * stats.sem(differences)) |
| mean = float(differences.mean()) |
| return mean - radius, mean + radius |
|
|
|
|
| def format_effect(row: dict[str, Any]) -> str: |
| return f"{row['difference']:+.3f} [{row['ci_low']:+.3f}, {row['ci_high']:+.3f}]" |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| reference_root = args.reference_root.resolve() |
| pregate_root = args.pregate_root.resolve() |
| output_dir = args.output_dir.resolve() |
| output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| reference: dict[int, dict[str, Any]] = {} |
| candidates: dict[str, dict[int, dict[str, Any]]] = { |
| variant: {} for variant in VARIANTS |
| } |
| for seed in range(3): |
| reference[seed] = load_result( |
| reference_root |
| / f"e3_c100_s1_relu6_seed{seed}" |
| / "evaluation/results.json" |
| ) |
| for variant, pattern in VARIANTS.items(): |
| candidates[variant][seed] = load_result( |
| pregate_root / pattern.format(seed=seed) / "evaluation/results.json" |
| ) |
|
|
| fixed = load_result( |
| pregate_root |
| / "e3_c100_pregate_v2_smooth_fixed_c6_seed0" |
| / "evaluation/results.json" |
| ) |
| effects: list[dict[str, Any]] = [] |
| aggregates: list[dict[str, Any]] = [] |
| for variant, runs in candidates.items(): |
| for metric in METRICS: |
| candidate_values = np.asarray( |
| [runs[seed]["overall"][metric] for seed in range(3)], dtype=np.float64 |
| ) |
| reference_values = np.asarray( |
| [reference[seed]["overall"][metric] for seed in range(3)], |
| dtype=np.float64, |
| ) |
| differences = candidate_values - reference_values |
| ci_low, ci_high = paired_interval(differences) |
| effects.append( |
| { |
| "variant": variant, |
| "reference": "relu6_self", |
| "metric": metric, |
| "difference": float(differences.mean()), |
| "ci_low": ci_low, |
| "ci_high": ci_high, |
| "seed_differences": [float(value) for value in differences], |
| "inference_unit": "paired_training_seed", |
| "seeds": 3, |
| } |
| ) |
| aggregates.append( |
| { |
| "variant": variant, |
| "metric": metric, |
| "mean": float(candidate_values.mean()), |
| "std": float(candidate_values.std(ddof=1)), |
| "seeds": 3, |
| } |
| ) |
|
|
| smooth_diagnostics = [ |
| candidates["smooth_corrected"][seed]["smooth_clip_diagnostics"] |
| for seed in range(3) |
| ] |
| global_min = min(float(item["global_min"]) for item in smooth_diagnostics) |
| severe_boundary = max( |
| float(item["severe_collapse_threshold"]) for item in smooth_diagnostics |
| ) |
| cap_pass = all( |
| bool(item["phase2_boundary_check_pass"]) for item in smooth_diagnostics |
| ) |
| fixed_caps = fixed["smooth_clip_diagnostics"] |
| fixed_pass = bool(fixed_caps) and math.isclose( |
| float(fixed_caps["global_mean"]), 6.0, abs_tol=1e-7 |
| ) |
| pregate_pass = cap_pass and fixed_pass |
|
|
| effect_index = {(row["variant"], row["metric"]): row for row in effects} |
| lines = [ |
| "# ImageNet v2 CIFAR-100 Pre-Gate Evidence", |
| "", |
| f"Decision: **{'PASS' if pregate_pass else 'FAIL'}**. This is a technical/controller pre-gate, not an accuracy-selection rule.", |
| "", |
| "All runs completed 100 fixed epochs and full clean plus five-corruption evaluation. " |
| "Intervals use the three paired training seeds; n=3 intervals are necessarily wide.", |
| "", |
| "| Variant | Clean Top-1 effect | Mean-corruption Top-1 effect | Clean NLL effect | Corruption NLL effect |", |
| "|---|---:|---:|---:|---:|", |
| ] |
| for variant in VARIANTS: |
| cells = [format_effect(effect_index[(variant, metric)]) for metric in METRICS] |
| lines.append(f"| {variant} | " + " | ".join(cells) + " |") |
| lines.extend( |
| [ |
| "", |
| "## Controller Audit", |
| "", |
| f"The learned-smooth minimum cap across seeds/blocks is `{global_min:.4f}`; " |
| f"the predefined severe-collapse boundary is `{severe_boundary:.4f}`. " |
| f"Controller non-collapse: `{cap_pass}`.", |
| f"The fixed-c6 controller remains at 6.0: `{fixed_pass}`.", |
| "", |
| "The old learned-cap collapse cannot be interpreted as adaptation because `raw_clip` " |
| "received weight decay. With zero controller weight decay, caps remain finite and " |
| "stage-dependent, so corrected learned-smooth is eligible for ImageNet.", |
| "", |
| "## Design Consequence", |
| "", |
| "Activation-only does not show the locally expected material loss. Its ImageNet test " |
| "must therefore not be an early fixed-sequence gate that suppresses the ReLU and " |
| "smooth hypotheses. Treat the four predeclared primary contrasts with simultaneous " |
| "family-wise correction, and interpret activation-only as an operator-replacement " |
| "test rather than unique causal evidence for multiplication.", |
| "", |
| ] |
| ) |
| report = "\n".join(lines) |
| (output_dir / "CONCLUSIONS.md").write_text(report, encoding="utf-8") |
| (output_dir / "results.json").write_text( |
| json.dumps( |
| { |
| "protocol": "imagenet-long-v2-pregate", |
| "decision": "passed" if pregate_pass else "failed", |
| "reference_root": str(reference_root), |
| "pregate_root": str(pregate_root), |
| "effects": effects, |
| "aggregates": aggregates, |
| "controller": { |
| "learned_global_min": global_min, |
| "severe_collapse_boundary": severe_boundary, |
| "learned_noncollapse_pass": cap_pass, |
| "fixed_c6_pass": fixed_pass, |
| }, |
| }, |
| indent=2, |
| sort_keys=True, |
| ) |
| + "\n", |
| encoding="utf-8", |
| ) |
| with (output_dir / "paired_seed_effects.csv").open( |
| "w", newline="", encoding="utf-8" |
| ) as handle: |
| writer = csv.DictWriter( |
| handle, |
| fieldnames=[ |
| "variant", |
| "reference", |
| "metric", |
| "difference", |
| "ci_low", |
| "ci_high", |
| "seed_differences", |
| "inference_unit", |
| "seeds", |
| ], |
| ) |
| writer.writeheader() |
| writer.writerows(effects) |
| print(output_dir) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
