| |
| """Evaluate cheap frozen-weight gate interventions on validation data.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| import sys |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
| import torch |
| from torch.nn import functional as F |
| from torch.utils.data import DataLoader, Subset |
| from torchvision import datasets, transforms |
| from torchvision.transforms import InterpolationMode |
|
|
| REPO_ROOT = Path(__file__).resolve().parents[1] |
| if str(REPO_ROOT) not in sys.path: |
| sys.path.insert(0, str(REPO_ROOT)) |
|
|
| from gmnet.analysis import ( |
| INTERVENTION_MODES, |
| install_gate_interventions, |
| load_model_checkpoint, |
| set_intervention_mode, |
| summarize_intervention_coherence, |
| ) |
|
|
|
|
| DEFAULT_CHECKPOINT = Path("/nfs/ywang29/GmNet/gmnet_s3.npy") |
| DEFAULT_OUTPUT_DIR = Path("/tmp/gmnet_runs/e4_interventions") |
| DEFAULT_DATA_ROOTS = { |
| "imagenet": Path("/s3-code/ywang29/datasets/imagenet-1k"), |
| "cifar100": Path("/tmp/gmnet_data/cifar-100"), |
| } |
| ECE_BINS = 15 |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--checkpoint", type=Path, default=DEFAULT_CHECKPOINT) |
| parser.add_argument("--data-root", type=Path) |
| parser.add_argument( |
| "--data-source-uri", |
| help="canonical upstream dataset URI recorded in result provenance", |
| ) |
| parser.add_argument( |
| "--data-staging-manifest", |
| type=Path, |
| help="JSON manifest proving how a local dataset cache was staged", |
| ) |
| parser.add_argument( |
| "--dataset", |
| choices=("auto", "imagenet", "cifar100"), |
| default="auto", |
| ) |
| parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR) |
| parser.add_argument("--batch-size", type=int, default=128) |
| parser.add_argument("--workers", type=int, default=8) |
| parser.add_argument( |
| "--max-samples", |
| type=int, |
| default=5_000, |
| help="deterministic random validation subset size; 0 evaluates all samples", |
| ) |
| parser.add_argument("--seed", type=int, default=20260712) |
| parser.add_argument( |
| "--device", |
| default="cuda:0" if torch.cuda.is_available() else "cpu", |
| ) |
| parser.add_argument( |
| "--modes", |
| nargs="+", |
| choices=INTERVENTION_MODES, |
| default=list(INTERVENTION_MODES), |
| ) |
| return parser.parse_args() |
|
|
|
|
| def build_validation_loader( |
| args: argparse.Namespace, |
| checkpoint_audit: dict[str, Any], |
| ) -> tuple[DataLoader, dict[str, Any]]: |
| checkpoint_dataset = str( |
| checkpoint_audit.get("data_config", {}).get("dataset", "imagenet") |
| ).lower() |
| dataset_name = args.dataset if args.dataset != "auto" else checkpoint_dataset |
| dataset_name = dataset_name.replace("-", "") |
| if dataset_name not in DEFAULT_DATA_ROOTS: |
| raise ValueError(f"unsupported validation dataset: {dataset_name}") |
| data_root = ( |
| args.data_root |
| if args.data_root is not None |
| else DEFAULT_DATA_ROOTS[dataset_name] |
| ).expanduser().resolve() |
|
|
| if dataset_name == "imagenet": |
| validation_root = data_root / "val" |
| if not validation_root.is_dir(): |
| raise FileNotFoundError( |
| f"ImageNet validation split not found: {validation_root}" |
| ) |
| transform = transforms.Compose( |
| [ |
| transforms.Resize(256, interpolation=InterpolationMode.BICUBIC), |
| transforms.CenterCrop(224), |
| transforms.ToTensor(), |
| transforms.Normalize( |
| mean=(0.485, 0.456, 0.406), |
| std=(0.229, 0.224, 0.225), |
| ), |
| ] |
| ) |
| dataset = datasets.ImageFolder(validation_root, transform=transform) |
| expected_classes = 1_000 |
| preprocess = "resize256_bicubic_centercrop224_imagenet_normalization" |
| else: |
| data_config = checkpoint_audit.get("data_config", {}) |
| mean = tuple(data_config.get("mean", (0.5071, 0.4867, 0.4408))) |
| std = tuple(data_config.get("std", (0.2675, 0.2565, 0.2761))) |
| transform = transforms.Compose( |
| [transforms.ToTensor(), transforms.Normalize(mean=mean, std=std)] |
| ) |
| dataset = datasets.CIFAR100( |
| data_root, |
| train=False, |
| transform=transform, |
| download=False, |
| ) |
| validation_root = data_root |
| expected_classes = 100 |
| preprocess = "tensor_cifar100_paper_normalization" |
| if len(dataset.classes) != expected_classes: |
| raise ValueError( |
| f"expected {expected_classes} classes, found {len(dataset.classes)}" |
| ) |
|
|
| total_samples = len(dataset) |
| requested = total_samples if args.max_samples == 0 else args.max_samples |
| sample_count = min(requested, total_samples) |
| if sample_count == total_samples: |
| indices = list(range(total_samples)) |
| subset_method = "full_validation_set_in_canonical_order" |
| else: |
| generator = torch.Generator().manual_seed(args.seed) |
| indices = torch.randperm( |
| total_samples, generator=generator |
| )[:sample_count].tolist() |
| subset_method = "torch_randperm_without_replacement" |
| subset = Subset(dataset, indices) |
| loader = DataLoader( |
| subset, |
| batch_size=args.batch_size, |
| shuffle=False, |
| num_workers=args.workers, |
| pin_memory=args.device.startswith("cuda"), |
| persistent_workers=args.workers > 0, |
| ) |
| index_digest = hashlib.sha256( |
| ",".join(str(index) for index in indices).encode("ascii") |
| ).hexdigest() |
| provenance: dict[str, Any] = { |
| "source_uri": args.data_source_uri or str(validation_root), |
| "access_path": str(validation_root), |
| "access_mode": "direct_path", |
| } |
| if args.data_staging_manifest is not None: |
| manifest_path = args.data_staging_manifest.expanduser().resolve() |
| if not manifest_path.is_file(): |
| raise FileNotFoundError( |
| f"data staging manifest not found: {manifest_path}" |
| ) |
| manifest_bytes = manifest_path.read_bytes() |
| manifest = json.loads(manifest_bytes) |
| if not isinstance(manifest, dict): |
| raise TypeError("data staging manifest must be a JSON mapping") |
| manifest_source = manifest.get("source") |
| if not isinstance(manifest_source, str) or not manifest_source: |
| raise ValueError("data staging manifest must identify its source") |
| expected_manifest_values = { |
| "classes": len(dataset.classes), |
| "images": total_samples, |
| } |
| for key, expected_value in expected_manifest_values.items(): |
| if key in manifest and int(manifest[key]) != expected_value: |
| raise ValueError( |
| f"staging manifest {key}={manifest[key]} does not match " |
| f"loaded dataset value {expected_value}" |
| ) |
| provenance.update( |
| { |
| "access_mode": "local_staging_cache", |
| "staging_manifest_path": str(manifest_path), |
| "staging_manifest_sha256": hashlib.sha256( |
| manifest_bytes |
| ).hexdigest(), |
| "staging_manifest": manifest, |
| } |
| ) |
| return loader, { |
| "root": str(validation_root), |
| "dataset": dataset_name, |
| "full_validation_samples": total_samples, |
| "evaluated_samples": sample_count, |
| "subset_method": subset_method, |
| "subset_seed": args.seed, |
| "subset_indices_sha256": index_digest, |
| "class_count": len(dataset.classes), |
| "preprocess": preprocess, |
| "provenance": provenance, |
| } |
|
|
|
|
| def _empty_metrics() -> dict[str, Any]: |
| return { |
| "samples": 0.0, |
| "top1_correct": 0.0, |
| "top5_correct": 0.0, |
| "baseline_agreement": 0.0, |
| "kl_from_baseline_sum": 0.0, |
| "logit_squared_error_sum": 0.0, |
| "logit_values": 0.0, |
| "nll_sum": 0.0, |
| "ece_counts": [0.0] * ECE_BINS, |
| "ece_confidence_sums": [0.0] * ECE_BINS, |
| "ece_correct_sums": [0.0] * ECE_BINS, |
| } |
|
|
|
|
| def _update_metrics( |
| metrics: dict[str, Any], |
| logits: torch.Tensor, |
| targets: torch.Tensor, |
| baseline_logits: torch.Tensor, |
| ) -> None: |
| batch_size = targets.numel() |
| predictions = logits.argmax(dim=1) |
| baseline_predictions = baseline_logits.argmax(dim=1) |
| top5 = logits.topk(5, dim=1).indices |
| probabilities = F.softmax(logits, dim=1) |
| confidence, _ = probabilities.max(dim=1) |
| metrics["samples"] += batch_size |
| metrics["top1_correct"] += (predictions == targets).sum().item() |
| metrics["top5_correct"] += top5.eq(targets[:, None]).any(dim=1).sum().item() |
| metrics["baseline_agreement"] += ( |
| predictions == baseline_predictions |
| ).sum().item() |
| metrics["kl_from_baseline_sum"] += F.kl_div( |
| F.log_softmax(logits, dim=1), |
| F.softmax(baseline_logits, dim=1), |
| reduction="sum", |
| ).item() |
| metrics["logit_squared_error_sum"] += ( |
| logits - baseline_logits |
| ).square().sum().item() |
| metrics["logit_values"] += logits.numel() |
| metrics["nll_sum"] += F.cross_entropy( |
| logits, targets, reduction="sum" |
| ).item() |
| bin_indices = torch.clamp((confidence * ECE_BINS).long(), max=ECE_BINS - 1) |
| correct = predictions.eq(targets).float() |
| for bin_index in range(ECE_BINS): |
| mask = bin_indices.eq(bin_index) |
| if mask.any(): |
| metrics["ece_counts"][bin_index] += mask.sum().item() |
| metrics["ece_confidence_sums"][bin_index] += confidence[mask].sum().item() |
| metrics["ece_correct_sums"][bin_index] += correct[mask].sum().item() |
|
|
|
|
| def _finalize_metrics(metrics: dict[str, Any]) -> dict[str, float | int]: |
| samples = int(metrics["samples"]) |
| if samples == 0: |
| raise ValueError("no samples were evaluated") |
| ece = 0.0 |
| for count, confidence_sum, correct_sum in zip( |
| metrics["ece_counts"], |
| metrics["ece_confidence_sums"], |
| metrics["ece_correct_sums"], |
| strict=True, |
| ): |
| if count: |
| ece += count / samples * abs(confidence_sum / count - correct_sum / count) |
| return { |
| "samples": samples, |
| "top1_percent": 100.0 * metrics["top1_correct"] / samples, |
| "top5_percent": 100.0 * metrics["top5_correct"] / samples, |
| "nll": metrics["nll_sum"] / samples, |
| "ece_percent": 100.0 * ece, |
| "prediction_agreement_with_baseline_percent": ( |
| 100.0 * metrics["baseline_agreement"] / samples |
| ), |
| "mean_kl_from_baseline": max( |
| metrics["kl_from_baseline_sum"] / samples, 0.0 |
| ), |
| "logit_rmse_from_baseline": math.sqrt( |
| metrics["logit_squared_error_sum"] / metrics["logit_values"] |
| ), |
| } |
|
|
|
|
| def render_markdown(result: dict[str, Any]) -> str: |
| rows = [] |
| for mode, metrics in result["interventions"].items(): |
| coherence = metrics["intervention_reference_coherence"][ |
| "mean_gate_input_pearson" |
| ] |
| rows.append( |
| f"| {mode} | {metrics['top1_percent']:.3f} | " |
| f"{metrics['top5_percent']:.3f} | " |
| f"{metrics['nll']:.5f} | {metrics['ece_percent']:.3f} | " |
| f"{metrics['prediction_agreement_with_baseline_percent']:.3f} | " |
| f"{metrics['mean_kl_from_baseline']:.6f} | " |
| f"{coherence!s} |" |
| ) |
| audit = result["checkpoint"] |
| data = result["data"] |
| return "\n".join( |
| [ |
| "# E4 Frozen Gate Intervention Audit", |
| "", |
| "## Scope", |
| "", |
| f"- Checkpoint: `{audit['path']}` (`{audit['sha256']}`).", |
| f"- Selected topology: `{audit['selected_topology']}`.", |
| f"- Data: deterministic random {data['evaluated_samples']}-image subset " |
| f"of {data['full_validation_samples']} {data['dataset']} validation " |
| "images.", |
| f"- Data source: `{data['provenance']['source_uri']}` via " |
| f"`{data['provenance']['access_mode']}` at " |
| f"`{data['provenance']['access_path']}`.", |
| "- This is a frozen-checkpoint sensitivity diagnostic. It is not a " |
| "matched-retraining causal accuracy result.", |
| "", |
| "## Results", |
| "", |
| "| Intervention | Top-1 (%) | Top-5 (%) | NLL | ECE (%) | " |
| "Baseline agreement (%) | KL from baseline | Reference Pearson |", |
| "|---|---:|---:|---:|---:|---:|---:|---:|", |
| *rows, |
| "", |
| "`stop_gradient` is intentionally excluded: it is forward-identical " |
| "during inference and can only be evaluated through retraining. " |
| "`mean_gate` uses the per-channel mean gate value over batch and " |
| "spatial dimensions at every block.", |
| "", |
| ] |
| ) |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| if "baseline" not in args.modes: |
| raise ValueError("baseline must be included to compute paired diagnostics") |
| device = torch.device(args.device) |
| if device.type == "cuda": |
| torch.cuda.set_device(device) |
|
|
| model, checkpoint_audit = load_model_checkpoint(args.checkpoint, device=device) |
| installed_gates = install_gate_interventions(model, seed=args.seed) |
| loader, data_audit = build_validation_loader(args, checkpoint_audit) |
| accumulators = {mode: _empty_metrics() for mode in args.modes} |
|
|
| started = time.time() |
| model.eval() |
| with torch.inference_mode(): |
| for images, targets in loader: |
| images = images.to(device, non_blocking=True) |
| targets = targets.to(device, non_blocking=True) |
|
|
| set_intervention_mode(model, "baseline") |
| baseline_logits = model(images) |
| for mode in args.modes: |
| if mode == "baseline": |
| logits = baseline_logits |
| else: |
| set_intervention_mode(model, mode) |
| logits = model(images) |
| _update_metrics( |
| accumulators[mode], logits, targets, baseline_logits |
| ) |
|
|
| if device.type == "cuda": |
| torch.cuda.synchronize(device) |
| interventions = {} |
| for mode, accumulator in accumulators.items(): |
| metrics = _finalize_metrics(accumulator) |
| metrics["intervention_reference_coherence"] = ( |
| summarize_intervention_coherence(model, mode) |
| ) |
| interventions[mode] = metrics |
|
|
| result = { |
| "schema_version": 1, |
| "experiment": "E4", |
| "status": "completed_frozen_checkpoint_diagnostic", |
| "claim_scope": ( |
| "Frozen-checkpoint forward intervention only. Accuracy differences " |
| "do not establish matched-retraining causality." |
| ), |
| "device": str(device), |
| "torch_version": torch.__version__, |
| "elapsed_seconds": time.time() - started, |
| "installed_gate_count": installed_gates, |
| "intervention_scope": "all_self_gate_blocks_jointly", |
| "intervention_definitions": { |
| "batch_shuffle": "fixed seeded batch permutation per gate block", |
| "spatial_shuffle": "fixed seeded spatial permutation per gate block", |
| "channel_shuffle": "fixed seeded channel permutation per gate block", |
| "mean_gate": ( |
| "per-channel gate-value mean over batch and spatial dimensions" |
| ), |
| "stop_gradient": "training-only; deliberately not evaluated", |
| }, |
| "checkpoint": checkpoint_audit, |
| "data": data_audit, |
| "interventions": interventions, |
| } |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| json_path = args.output_dir / "results.json" |
| markdown_path = args.output_dir / "RESULTS.md" |
| json_path.write_text(json.dumps(result, indent=2, sort_keys=True), encoding="utf-8") |
| markdown_path.write_text(render_markdown(result), encoding="utf-8") |
| print(json.dumps({"results": str(json_path), "markdown": str(markdown_path)})) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
