| """ |
| msc_lib.py v1.0.0 -- MSC Phase 0 shared library. |
| |
| Uploaded once by NB00_bootstrap, downloaded identically by every run notebook, |
| and pinned by sha256 in config.json so that "did all four runs execute the same |
| code?" is answerable by a hash rather than by memory. |
| |
| Design principle (inherited from E2AM): HuggingFace is the *only* permanent |
| store. /kaggle/working is scratch for artifacts, /kaggle/temp is scratch for |
| datasets and regenerable intermediates. A session can die at any instant. |
| |
| Parallel-safety (inherited from the AI-detection build): every run writes ONLY |
| to runs/{run_id}/ and per_sample/{run_id}/. Four accounts never touch the same |
| path, so concurrent commits collide only at the repo-revision level, which is |
| handled by push stagger + 412/409 retry. |
| |
| What this library adds over E2AM, because the science needs it: |
| - Checkpoints carry ALL FOUR RNG states. Without them a resumed run is not |
| the same run, the seeds are meaningless, and the noise ceiling -- which is |
| the denominator of every transfer number in the project -- is invalid. |
| - config_hash asserted on resume, computed over the `science` block only. |
| - SIGTERM / atexit / KeyboardInterrupt all trigger an immediate full push. |
| - A wall-clock push timer (20 min) rather than an epoch-milestone timer, |
| staggered per account. |
| - An eleven-stage machine with STATE.json, so any cell is safe to re-run and |
| a cold session resumes at the first incomplete stage. |
| - Row-alignment assertions and a dataset fingerprint, because a misaligned |
| per-sample table destroys real correlations or manufactures fake ones and |
| nothing downstream looks broken. |
| |
| Sections: |
| 1. utils -- atomic io, hashing, RNG state, seeding |
| 2. hf_store -- background uploader, batched commits, backoff |
| 3. stages -- STATE.json stage machine |
| 4. config -- science/runtime split, config_hash |
| 5. data -- CIFAR-100, canonical ordering, fingerprint |
| 6. models -- resnet32x4 / wrn-40-2, CIFAR recipe faithful |
| 7. exits -- exit heads, pooled-feature cache, 3 head seeds |
| 8. energy -- NVML sampler |
| 9. checkpoint -- full-state save/load |
| 10. train -- training loop, gate, signal handlers |
| 11. sweeps -- depth / resolution oracle sweeps |
| 12. battery -- 7 difficulty scores |
| 13. emit -- per-sample Parquet with assertions |
| """ |
| from __future__ import annotations |
|
|
| __version__ = "1.1.0" |
|
|
| import atexit |
| import csv |
| import hashlib |
| import json |
| import os |
| import pickle |
| import random |
| import shutil |
| import signal |
| import sys |
| import threading |
| import time |
| import traceback |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple |
|
|
| import numpy as np |
|
|
| |
| |
| |
| |
| |
| |
| try: |
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| _HAS_TORCH = True |
| except Exception: |
| _HAS_TORCH = False |
|
|
| class _Missing: |
| """Every attribute access returns something that raises when used.""" |
|
|
| def __init__(self, name="torch"): |
| self._name = name |
|
|
| def __getattr__(self, item): |
| if item == "Module": |
| return object |
| if item in ("no_grad", "inference_mode"): |
| def _passthrough(fn=None): |
| if fn is None: |
| return _passthrough |
| return fn |
| return _passthrough |
| def _raise(*a, **k): |
| raise RuntimeError( |
| f"{self._name}.{item} used but PyTorch is not installed. " |
| f"This code path requires a GPU session.") |
| return _raise |
|
|
| torch = _Missing("torch") |
| nn = _Missing("torch.nn") |
| F = _Missing("torch.nn.functional") |
|
|
|
|
| |
| |
| |
|
|
| def now_iso() -> str: |
| import datetime |
| return datetime.datetime.now(datetime.timezone.utc).isoformat() |
|
|
|
|
| def ensure_dir(p) -> Path: |
| p = Path(p) |
| p.mkdir(parents=True, exist_ok=True) |
| return p |
|
|
|
|
| def atomic_write_bytes(path, data: bytes) -> None: |
| """Write via a temp file + os.replace. os.replace is atomic on POSIX. |
| |
| Never write directly to a file another process may read, and never write |
| directly to ckpt_last.pt -- a session killed mid-write leaves a truncated |
| file and the run is lost. |
| """ |
| path = Path(path) |
| ensure_dir(path.parent) |
| tmp = path.with_suffix(path.suffix + ".tmp") |
| with open(tmp, "wb") as f: |
| f.write(data) |
| f.flush() |
| os.fsync(f.fileno()) |
| os.replace(tmp, path) |
|
|
|
|
| def atomic_write_text(path, text: str) -> None: |
| atomic_write_bytes(path, text.encode("utf-8")) |
|
|
|
|
| def atomic_write_json(path, obj) -> None: |
| atomic_write_text(path, json.dumps(obj, indent=2, sort_keys=True, default=str)) |
|
|
|
|
| def atomic_save_torch(path, obj) -> None: |
| path = Path(path) |
| ensure_dir(path.parent) |
| tmp = path.with_suffix(path.suffix + ".tmp") |
| torch.save(obj, tmp) |
| os.replace(tmp, path) |
|
|
|
|
| def read_json(path, default=None): |
| try: |
| return json.loads(Path(path).read_text(encoding="utf-8")) |
| except Exception: |
| return default |
|
|
|
|
| def sha256_file(path) -> str: |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(1 << 20), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def sha256_bytes(b: bytes) -> str: |
| return hashlib.sha256(b).hexdigest() |
|
|
|
|
| def canonical_json(obj) -> str: |
| """Stable serialisation for hashing: sorted keys, normalised numerics. |
| |
| Floats are round-tripped through repr so that 0.05 hashes identically on |
| every platform and every Python build. |
| """ |
| def norm(o): |
| if isinstance(o, dict): |
| return {str(k): norm(o[k]) for k in sorted(o, key=str)} |
| if isinstance(o, (list, tuple)): |
| return [norm(x) for x in o] |
| if isinstance(o, float): |
| return repr(float(o)) |
| if isinstance(o, (np.integer,)): |
| return int(o) |
| if isinstance(o, (np.floating,)): |
| return repr(float(o)) |
| return o |
| return json.dumps(norm(obj), sort_keys=True, separators=(",", ":")) |
|
|
|
|
| def derive_seed(*parts) -> int: |
| """Deterministic 31-bit seed from any tuple of identifiers. |
| |
| Used so that every source of randomness gets its own seed derived from the |
| run seed, rather than sharing one global stream. Sharing a stream between |
| seed 1 and seed 2 would inflate the noise ceiling and bias every transfer |
| number in the optimistic direction. |
| """ |
| s = ":".join(str(p) for p in parts) |
| return int(hashlib.sha256(s.encode()).hexdigest()[:15], 16) % (2 ** 31 - 1) |
|
|
|
|
| def set_all_seeds(seed: int, deterministic: bool = True) -> Dict[str, Any]: |
| """Seed python / numpy / torch / cuda and request deterministic kernels. |
| |
| Returns a dict recording what was actually achieved -- determinism is not |
| always available (some ops have no deterministic CUDA implementation), and |
| where it is disabled that fact must be recorded in the config rather than |
| silently assumed. |
| """ |
| random.seed(seed) |
| np.random.seed(seed % (2 ** 32 - 1)) |
| info = {"seed": int(seed), "deterministic": False, "reason": None} |
| if not _HAS_TORCH: |
| return info |
| torch.manual_seed(seed) |
| if torch.cuda.is_available(): |
| torch.cuda.manual_seed_all(seed) |
| if deterministic: |
| os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") |
| try: |
| torch.backends.cudnn.deterministic = True |
| torch.backends.cudnn.benchmark = False |
| torch.use_deterministic_algorithms(True) |
| info["deterministic"] = True |
| except Exception as e: |
| try: |
| torch.use_deterministic_algorithms(True, warn_only=True) |
| except Exception: |
| pass |
| info["reason"] = f"{type(e).__name__}: {e}" |
| print(f"[SEED] full determinism unavailable -> warn_only. {info['reason']}") |
| else: |
| info["reason"] = "disabled by config" |
| return info |
|
|
|
|
| def rng_state() -> Dict[str, Any]: |
| """Capture every RNG stream that affects training. |
| |
| Omitting any of these means a resumed run is not the same run as an |
| uninterrupted one, which makes the seeds -- and therefore the entire |
| noise ceiling -- meaningless. |
| """ |
| st = { |
| "python": random.getstate(), |
| "numpy": np.random.get_state(), |
| "torch": torch.get_rng_state(), |
| "cuda": torch.cuda.get_rng_state_all() if torch.cuda.is_available() else [], |
| } |
| return st |
|
|
|
|
| def rng_restore(st: Dict[str, Any]) -> None: |
| random.setstate(st["python"]) |
| np.random.set_state(st["numpy"]) |
| torch.set_rng_state(st["torch"].cpu() if hasattr(st["torch"], "cpu") else st["torch"]) |
| if torch.cuda.is_available() and st.get("cuda"): |
| try: |
| torch.cuda.set_rng_state_all([s.cpu() if hasattr(s, "cpu") else s |
| for s in st["cuda"]]) |
| except Exception as e: |
| print(f"[RNG] cuda state restore failed ({e}) -- continuity is void") |
|
|
|
|
| def worker_init_fn_factory(base_seed: int) -> Callable[[int], None]: |
| """Per-worker seeding. Without this, dataloader workers inherit a seed |
| derived from torch's global generator in a way that is not stable across |
| resume, and augmentation order silently diverges.""" |
| def _init(worker_id: int) -> None: |
| s = (base_seed + worker_id) % (2 ** 31 - 1) |
| random.seed(s) |
| np.random.seed(s % (2 ** 32 - 1)) |
| torch.manual_seed(s) |
| return _init |
|
|
|
|
| def disk_free_mb(path="/kaggle/working") -> int: |
| try: |
| return shutil.disk_usage(str(path)).free // (1024 * 1024) |
| except Exception: |
| return 1 << 30 |
|
|
|
|
| def hardware_report() -> Dict[str, Any]: |
| rep: Dict[str, Any] = {"time_utc": now_iso(), "python": sys.version.split()[0]} |
| try: |
| rep["torch"] = torch.__version__ |
| rep["cuda_available"] = bool(torch.cuda.is_available()) |
| if torch.cuda.is_available(): |
| rep["gpu_name"] = torch.cuda.get_device_name(0) |
| rep["gpu_count"] = torch.cuda.device_count() |
| rep["cuda_version"] = torch.version.cuda |
| rep["cudnn_version"] = torch.backends.cudnn.version() |
| rep["vram_gb"] = round( |
| torch.cuda.get_device_properties(0).total_memory / 1e9, 2) |
| except Exception as e: |
| rep["torch_error"] = str(e) |
| try: |
| import torchvision |
| rep["torchvision"] = torchvision.__version__ |
| except Exception: |
| pass |
| try: |
| import subprocess |
| rep["nvidia_smi"] = subprocess.run( |
| ["nvidia-smi", "--query-gpu=name,driver_version", |
| "--format=csv,noheader"], |
| capture_output=True, text=True, timeout=10).stdout.strip() |
| except Exception: |
| pass |
| try: |
| import subprocess |
| rep["pip_freeze"] = subprocess.run( |
| [sys.executable, "-m", "pip", "freeze"], |
| capture_output=True, text=True, timeout=120).stdout.splitlines() |
| except Exception: |
| pass |
| return rep |
|
|
|
|
| class Tee: |
| """Mirror stdout to a file so logs/{run_id}/stdout.log is a real artifact. |
| |
| The thing everyone wishes they had kept. |
| """ |
|
|
| def __init__(self, path): |
| self.path = Path(path) |
| ensure_dir(self.path.parent) |
| self._f = open(self.path, "a", encoding="utf-8", buffering=1) |
| self._stdout = sys.stdout |
|
|
| def write(self, s): |
| self._stdout.write(s) |
| try: |
| self._f.write(s) |
| except Exception: |
| pass |
|
|
| def flush(self): |
| self._stdout.flush() |
| try: |
| self._f.flush() |
| except Exception: |
| pass |
|
|
| def install(self): |
| sys.stdout = self |
| return self |
|
|
| def close(self): |
| sys.stdout = self._stdout |
| try: |
| self._f.close() |
| except Exception: |
| pass |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class _Pending: |
| local_path: str |
| repo_path: str |
| fingerprint: str |
| enqueued_at: float |
|
|
|
|
| class HFStore: |
| """Batched, rate-limited, crash-tolerant uploader for one HF repo. |
| |
| One worker thread. Files are buffered and flushed as a SINGLE commit when |
| the interval elapses, the buffer fills, or flush() is called. Six files in |
| six commits is six times the rate-limit consumption for no benefit. |
| |
| Concurrency: Phase 0 runs four accounts against the same repos at once. |
| Two failure modes are handled differently and must not be conflated: |
| |
| 429 (rate limit) -> exponential backoff 60/120/240/600s. Slow down. |
| 412 / 409 (revision conflict from a concurrent commit) -> immediate retry |
| with 1-5s jitter. A 60s sleep here would serialise |
| all four accounts for no reason. |
| |
| A failed push NEVER propagates into training. It is logged and retried on |
| the next cycle. |
| """ |
|
|
| MAX_ATTEMPTS_429 = 6 |
| MAX_ATTEMPTS_CONFLICT = 5 |
| BACKOFF_429 = (60, 120, 240, 600, 600, 600) |
| BATCH_MAX_FILES = 200 |
| BATCH_MAX_BYTES = 2 * 1024 * 1024 * 1024 |
|
|
| def __init__(self, repo_id: str, token: str, repo_type: str = "model", |
| interval_sec: float = 1200.0, offset_sec: float = 0.0, |
| commits_per_hour: int = 30, private: bool = True): |
| self.repo_id = repo_id |
| self.token = token |
| self.repo_type = repo_type |
| self.interval_sec = float(interval_sec) |
| self.offset_sec = float(offset_sec) |
| self.commits_per_hour = int(commits_per_hour) |
| self.private = private |
|
|
| self._buffer: Dict[str, _Pending] = {} |
| self._buf_lock = threading.Lock() |
| self._fingerprints: Set[str] = set() |
| self._fp_lock = threading.Lock() |
| self._commit_times: List[float] = [] |
| self._commit_lock = threading.Lock() |
| self._stop = threading.Event() |
| self._wakeup = threading.Event() |
| self._thread: Optional[threading.Thread] = None |
| self._in_commit = False |
| self._api = None |
| self._stats = {"queued": 0, "uploaded": 0, "dedup_skipped": 0, |
| "commits": 0, "retries_429": 0, "retries_conflict": 0, |
| "rate_waits": 0, "failed": 0} |
| self._stats_lock = threading.Lock() |
|
|
| |
| def start(self) -> bool: |
| try: |
| from huggingface_hub import HfApi, create_repo |
| create_repo(repo_id=self.repo_id, token=self.token, exist_ok=True, |
| repo_type=self.repo_type, private=self.private) |
| self._api = HfApi(token=self.token) |
| except Exception as e: |
| print(f"[HF] init failed for {self.repo_id}: {e}") |
| return False |
| self._stop.clear() |
| self._thread = threading.Thread(target=self._loop, daemon=True, |
| name=f"hf-{self.repo_type}") |
| self._thread.start() |
| print(f"[HF] {self.repo_id} ready " |
| f"(interval={self.interval_sec/60:.0f}min, " |
| f"offset={self.offset_sec/60:.0f}min, " |
| f"<={self.commits_per_hour} commits/hr)") |
| return True |
|
|
| def healthcheck(self, session_id: str) -> bool: |
| """Live write test. Fail fast in Cell 1 rather than after three hours. |
| |
| A run that discovers at the end that it cannot push is strictly worse |
| than one that never starts. |
| """ |
| try: |
| from huggingface_hub import CommitOperationAdd, CommitOperationDelete |
| p = f"_healthcheck/{session_id}.txt" |
| self._api.create_commit( |
| repo_id=self.repo_id, repo_type=self.repo_type, |
| operations=[CommitOperationAdd( |
| path_in_repo=p, |
| path_or_fileobj=now_iso().encode())], |
| commit_message="healthcheck") |
| self._api.create_commit( |
| repo_id=self.repo_id, repo_type=self.repo_type, |
| operations=[CommitOperationDelete(path_in_repo=p)], |
| commit_message="healthcheck cleanup") |
| print(f"[HF] write healthcheck OK -> {self.repo_id}") |
| return True |
| except Exception as e: |
| print(f"[HF] WRITE HEALTHCHECK FAILED for {self.repo_id}: {e}") |
| return False |
|
|
| def stop(self, drain: bool = True, timeout: float = 300.0) -> None: |
| if self._thread is None: |
| return |
| if drain: |
| self.flush(timeout=timeout) |
| self._stop.set() |
| self._wakeup.set() |
| self._thread.join(timeout=15) |
| self._thread = None |
|
|
| |
| def enqueue(self, local_path, repo_path: str) -> bool: |
| """Buffer a file for the next batched commit. False if deduplicated.""" |
| local_path = Path(local_path) |
| if not local_path.exists(): |
| return False |
| fp = self._fingerprint(local_path, repo_path) |
| with self._fp_lock: |
| if fp in self._fingerprints: |
| with self._stats_lock: |
| self._stats["dedup_skipped"] += 1 |
| return False |
| repo_path = repo_path.replace("\\", "/") |
| with self._buf_lock: |
| self._buffer[repo_path] = _Pending(str(local_path), repo_path, |
| fp, time.time()) |
| n = len(self._buffer) |
| nbytes = sum(self._safe_size(p.local_path) |
| for p in self._buffer.values()) |
| with self._stats_lock: |
| self._stats["queued"] += 1 |
| if n >= self.BATCH_MAX_FILES or nbytes >= self.BATCH_MAX_BYTES: |
| self._wakeup.set() |
| return True |
|
|
| def enqueue_dir(self, local_dir, repo_prefix: str, |
| skip: Sequence[str] = ()) -> int: |
| local_dir = Path(local_dir) |
| if not local_dir.exists(): |
| return 0 |
| n = 0 |
| for f in sorted(local_dir.rglob("*")): |
| if not f.is_file(): |
| continue |
| rel = f.relative_to(local_dir).as_posix() |
| if any(s in rel for s in skip) or rel.endswith(".tmp"): |
| continue |
| n += int(self.enqueue(f, f"{repo_prefix.rstrip('/')}/{rel}")) |
| return n |
|
|
| def flush(self, timeout: float = 300.0) -> bool: |
| self._wakeup.set() |
| deadline = time.time() + timeout |
| while time.time() < deadline: |
| with self._buf_lock: |
| empty = not self._buffer |
| if empty and not self._in_commit: |
| return True |
| time.sleep(0.5) |
| print(f"[HF] flush timed out after {timeout}s for {self.repo_id}") |
| return False |
|
|
| def stats(self) -> Dict[str, int]: |
| with self._stats_lock: |
| with self._buf_lock: |
| pending = len(self._buffer) |
| return dict(self._stats, pending=pending, |
| commits_last_hour=self._commits_in_last_hour()) |
|
|
| def list_files(self) -> Set[str]: |
| try: |
| return set(self._api.list_repo_files(repo_id=self.repo_id, |
| repo_type=self.repo_type)) |
| except Exception as e: |
| print(f"[HF] list_repo_files: {e}") |
| return set() |
|
|
| def download(self, repo_path: str, local_path=None) -> Optional[Path]: |
| try: |
| from huggingface_hub import hf_hub_download |
| p = hf_hub_download(repo_id=self.repo_id, filename=repo_path, |
| repo_type=self.repo_type, token=self.token) |
| if local_path is not None: |
| ensure_dir(Path(local_path).parent) |
| shutil.copy2(p, local_path) |
| return Path(local_path) |
| return Path(p) |
| except Exception as e: |
| msg = str(e).lower() |
| if "404" not in msg and "not found" not in msg and "entrynotfound" not in msg: |
| print(f"[HF] download {repo_path}: {e}") |
| return None |
|
|
| def snapshot(self, local_dir, allow_patterns: Optional[List[str]] = None) -> bool: |
| """Pull only what this run needs. /kaggle/working is 20 GB and shared |
| with the artifacts, so never snapshot the whole repo.""" |
| try: |
| from huggingface_hub import snapshot_download |
| ensure_dir(local_dir) |
| snapshot_download(repo_id=self.repo_id, repo_type=self.repo_type, |
| local_dir=str(local_dir), token=self.token, |
| allow_patterns=allow_patterns) |
| return True |
| except Exception as e: |
| msg = str(e).lower() |
| if "404" in msg or "not found" in msg: |
| print(f"[HF] no prior snapshot in {self.repo_id} (fresh repo)") |
| else: |
| print(f"[HF] snapshot warning: {e}") |
| return False |
|
|
| |
| @staticmethod |
| def _fingerprint(local_path: Path, repo_path: str) -> str: |
| try: |
| st = local_path.stat() |
| return f"{repo_path}|{st.st_size}|{int(st.st_mtime)}" |
| except Exception: |
| return f"{repo_path}|?|{time.time()}" |
|
|
| @staticmethod |
| def _safe_size(p: str) -> int: |
| try: |
| return Path(p).stat().st_size |
| except Exception: |
| return 0 |
|
|
| def _commits_in_last_hour(self) -> int: |
| now = time.time() |
| with self._commit_lock: |
| self._commit_times = [t for t in self._commit_times if now - t < 3600] |
| return len(self._commit_times) |
|
|
| def _wait_for_rate_limit(self) -> None: |
| while not self._stop.is_set(): |
| now = time.time() |
| with self._commit_lock: |
| self._commit_times = [t for t in self._commit_times |
| if now - t < 3600] |
| if len(self._commit_times) < self.commits_per_hour: |
| return |
| oldest = self._commit_times[0] |
| wait = max(1.0, 3600 - (now - oldest) + 1.0) |
| with self._stats_lock: |
| self._stats["rate_waits"] += 1 |
| print(f"[HF] rate guard: {len(self._commit_times)} commits/hr, " |
| f"sleeping {wait:.0f}s") |
| if self._stop.wait(wait): |
| return |
|
|
| def _loop(self) -> None: |
| |
| |
| if self.offset_sec > 0: |
| if self._stop.wait(self.offset_sec): |
| return |
| while not self._stop.is_set(): |
| self._wakeup.wait(timeout=self.interval_sec) |
| self._wakeup.clear() |
| if self._stop.is_set(): |
| break |
| with self._buf_lock: |
| if not self._buffer: |
| continue |
| batch = list(self._buffer.values()) |
| self._buffer.clear() |
| self._wait_for_rate_limit() |
| self._in_commit = True |
| try: |
| if not self._commit_batch(batch): |
| with self._buf_lock: |
| for pf in batch: |
| self._buffer.setdefault(pf.repo_path, pf) |
| finally: |
| self._in_commit = False |
| with self._buf_lock: |
| final = list(self._buffer.values()) |
| self._buffer.clear() |
| if final: |
| self._commit_batch(final) |
|
|
| def _commit_batch(self, batch: List[_Pending]) -> bool: |
| if not batch: |
| return True |
| try: |
| from huggingface_hub import CommitOperationAdd |
| except Exception as e: |
| print(f"[HF] huggingface_hub missing CommitOperationAdd: {e}") |
| return False |
|
|
| ops, kept = [], [] |
| for pf in batch: |
| if not Path(pf.local_path).exists(): |
| continue |
| ops.append(CommitOperationAdd(path_in_repo=pf.repo_path, |
| path_or_fileobj=pf.local_path)) |
| kept.append(pf) |
| if not ops: |
| return True |
|
|
| attempt_429 = 0 |
| attempt_conflict = 0 |
| while True: |
| try: |
| self._api.create_commit( |
| repo_id=self.repo_id, repo_type=self.repo_type, |
| operations=ops, |
| commit_message=f"msc: {len(ops)} files @ {now_iso()}") |
| with self._commit_lock: |
| self._commit_times.append(time.time()) |
| with self._fp_lock: |
| for pf in kept: |
| self._fingerprints.add(pf.fingerprint) |
| with self._stats_lock: |
| self._stats["commits"] += 1 |
| self._stats["uploaded"] += len(ops) |
| print(f"[HF] committed {len(ops)} files -> {self.repo_id}") |
| return True |
| except BaseException as e: |
| code = self._status_code(e) |
| if code == 429: |
| if attempt_429 >= self.MAX_ATTEMPTS_429: |
| break |
| wait = self.BACKOFF_429[min(attempt_429, |
| len(self.BACKOFF_429) - 1)] |
| attempt_429 += 1 |
| with self._stats_lock: |
| self._stats["retries_429"] += 1 |
| print(f"[HF] 429 rate limited, backoff {wait}s " |
| f"(attempt {attempt_429})") |
| if self._stop.wait(wait): |
| break |
| elif code in (409, 412): |
| |
| if attempt_conflict >= self.MAX_ATTEMPTS_CONFLICT: |
| break |
| attempt_conflict += 1 |
| with self._stats_lock: |
| self._stats["retries_conflict"] += 1 |
| wait = random.uniform(1.0, 5.0) |
| print(f"[HF] {code} revision conflict, retry in " |
| f"{wait:.1f}s (attempt {attempt_conflict})") |
| if self._stop.wait(wait): |
| break |
| else: |
| print(f"[HF] commit failed ({type(e).__name__}): {e}") |
| break |
| with self._stats_lock: |
| self._stats["failed"] += 1 |
| return False |
|
|
| @staticmethod |
| def _status_code(e: BaseException) -> Optional[int]: |
| for attr in ("response", "request"): |
| r = getattr(e, attr, None) |
| code = getattr(r, "status_code", None) |
| if code: |
| return int(code) |
| s = str(e) |
| for c in (429, 412, 409, 401, 403): |
| if str(c) in s: |
| return c |
| return None |
|
|
|
|
| def load_hf_token() -> str: |
| """Kaggle Secrets first, then environment. Never printed anywhere.""" |
| try: |
| from kaggle_secrets import UserSecretsClient |
| t = UserSecretsClient().get_secret("HF_TOKEN") |
| if t: |
| return t.strip() |
| except Exception: |
| pass |
| for k in ("HF_TOKEN", "HUGGINGFACE_TOKEN", "HUGGING_FACE_HUB_TOKEN"): |
| if os.environ.get(k): |
| return os.environ[k].strip() |
| raise RuntimeError( |
| "HF_TOKEN not found. Add it under Kaggle -> Add-ons -> Secrets " |
| "with the name HF_TOKEN, and enable it for this notebook.") |
|
|
|
|
| |
| |
| |
|
|
| STAGES = [ |
| "env_capture", |
| "dataset", |
| "budgets", |
| "train_backbone", |
| "accuracy_gate", |
| "cache_features", |
| "train_heads", |
| "sweep_depth", |
| "sweep_resolution", |
| "difficulty_battery", |
| "emit_parquet", |
| "finalise", |
| ] |
|
|
|
|
| class StageMachine: |
| """Idempotency contract. |
| |
| STATE.json records which stages are done and the sha256 of their outputs. |
| Every cell opens with `if sm.done(name): skip`. Consequences: |
| |
| - Every cell is safe to re-run; the second run is a hash-verifying no-op. |
| - A fresh session with empty local disk pulls STATE.json, finds the first |
| incomplete stage, pulls only what that stage needs, and continues. |
| |
| Stage 5 (cache_features) writes to /kaggle/temp and is never pushed: it is |
| recomputed deterministically from ckpt_last, which is the definition of not |
| needing to store it. |
| """ |
|
|
| def __init__(self, local_path, store: Optional[HFStore], repo_path: str): |
| self.local_path = Path(local_path) |
| self.store = store |
| self.repo_path = repo_path |
| self.state: Dict[str, Any] = {"stages": {}, "schema": "msc_v1"} |
| self._lock = threading.Lock() |
|
|
| def pull(self) -> Dict[str, Any]: |
| if self.store is not None: |
| p = self.store.download(self.repo_path) |
| if p is not None: |
| try: |
| shutil.copy2(p, self.local_path) |
| except Exception: |
| pass |
| loaded = read_json(self.local_path, default=None) |
| if loaded: |
| self.state = loaded |
| return self.state |
|
|
| def done(self, stage: str) -> bool: |
| return bool(self.state.get("stages", {}).get(stage, {}).get("done")) |
|
|
| def first_incomplete(self) -> str: |
| for s in STAGES: |
| if not self.done(s): |
| return s |
| return "finalise" |
|
|
| def mark(self, stage: str, outputs: Optional[Dict[str, str]] = None, |
| **extra) -> None: |
| with self._lock: |
| self.state.setdefault("stages", {})[stage] = { |
| "done": True, "at": now_iso(), |
| "sha256": outputs or {}, **extra, |
| } |
| self.state["updated_utc"] = now_iso() |
| atomic_write_json(self.local_path, self.state) |
| if self.store is not None: |
| self.store.enqueue(self.local_path, self.repo_path) |
| print(f"[STAGE] {stage} complete") |
|
|
| def note(self, key: str, value) -> None: |
| with self._lock: |
| self.state.setdefault("notes", {})[key] = value |
| atomic_write_json(self.local_path, self.state) |
| if self.store is not None: |
| self.store.enqueue(self.local_path, self.repo_path) |
|
|
|
|
| class RunStatus: |
| """STATUS.json heartbeat. With four concurrent sessions this is the only |
| thing that makes a dead session detectable.""" |
|
|
| def __init__(self, local_path, store: Optional[HFStore], repo_path: str, |
| run_id: str): |
| self.local_path = Path(local_path) |
| self.store = store |
| self.repo_path = repo_path |
| self.run_id = run_id |
| self.data: Dict[str, Any] = { |
| "run_id": run_id, "state": "starting", "stage": None, |
| "epoch": -1, "anomalies": [], "started_at": now_iso(), |
| } |
|
|
| def update(self, **fields) -> None: |
| self.data.update(fields) |
| self.data["updated_at"] = now_iso() |
| atomic_write_json(self.local_path, self.data) |
| if self.store is not None: |
| self.store.enqueue(self.local_path, self.repo_path) |
|
|
| def anomaly(self, kind: str, detail: str) -> None: |
| self.data.setdefault("anomalies", []).append( |
| {"kind": kind, "detail": detail, "at": now_iso()}) |
| print(f"[ANOMALY] {kind}: {detail}") |
| self.update() |
|
|
|
|
| class Registry: |
| """Optimistic claim protocol over HF. No locking primitive exists, so this |
| is advisory -- but with dynamic claiming it is what decides who does what. |
| |
| Design point inherited from the AI-detection build: **one writer per path**. |
| We never append to a shared runs.jsonl from multiple accounts (concurrent |
| appends conflict and lose entries). Instead each run has its own claim file |
| and its own done file, so two accounts can never write the same object: |
| |
| registry/claims/{run_id}.json written only by whoever holds the run |
| registry/done/{run_id}.json written once, at completion |
| registry/runs.jsonl static manifest from NB00, never appended |
| |
| State of a run is then derived, not stored: |
| DONE -> done/{run_id}.json exists |
| HELD -> claims/{run_id}.json exists and updated_at is < stale_h old |
| AVAILABLE -> otherwise (includes a dead session's stale claim) |
| |
| Race handling: two workers can still claim the same run in the same second. |
| After writing our claim we wait a random 3-8 s and re-read; if the winner |
| is not us, we yield and pick another. That is enough for a handful of |
| accounts and costs nothing when there is no contention. |
| """ |
|
|
| STALE_H = 2.0 |
|
|
| def __init__(self, store: HFStore, account: str, session_id: str, |
| namespace: str = ""): |
| """`namespace` isolates a queue. Smoke runs use "_smoke/" so that a |
| 500-sample 2-epoch rehearsal can exercise the entire claim protocol |
| without marking a real run done -- which would make the queue skip it |
| forever, and would look exactly like success.""" |
| self.store = store |
| self.account = str(account) |
| self.session_id = session_id |
| self.ns = namespace |
| self._tmp = ensure_dir(Path("/tmp/msc_registry")) |
|
|
| def _claim_path(self, run_id: str) -> str: |
| return f"registry/{self.ns}claims/{run_id}.json" |
|
|
| def _done_path(self, run_id: str) -> str: |
| return f"registry/{self.ns}done/{run_id}.json" |
|
|
| |
| def _list(self) -> Set[str]: |
| return self.store.list_files() |
|
|
| def _read(self, repo_path: str) -> Optional[Dict[str, Any]]: |
| p = self.store.download(repo_path) |
| return read_json(p, default=None) if p else None |
|
|
| def status(self, run_ids: Sequence[str]) -> Dict[str, Dict[str, Any]]: |
| files = self._list() |
| now = time.time() |
| out: Dict[str, Dict[str, Any]] = {} |
| for rid in run_ids: |
| if self._done_path(rid) in files: |
| out[rid] = {"state": "done"} |
| continue |
| cp = self._claim_path(rid) |
| if cp in files: |
| c = self._read(cp) or {} |
| age_h = (now - float(c.get("epoch_s", 0))) / 3600.0 |
| if age_h < self.STALE_H: |
| out[rid] = {"state": "held", "by": c.get("account"), |
| "session": c.get("session"), "age_h": round(age_h, 2)} |
| else: |
| out[rid] = {"state": "stale", "by": c.get("account"), |
| "age_h": round(age_h, 2)} |
| else: |
| out[rid] = {"state": "available"} |
| return out |
|
|
| def print_board(self, run_ids: Sequence[str]) -> Dict[str, Dict[str, Any]]: |
| st = self.status(run_ids) |
| print(f"{'run_id':34s} {'state':10s} detail") |
| print("-" * 74) |
| for rid in run_ids: |
| s = st[rid] |
| detail = "" |
| if s["state"] in ("held", "stale"): |
| detail = f"account {s.get('by')}, {s.get('age_h')} h ago" |
| print(f"{rid:34s} {s['state']:10s} {detail}") |
| return st |
|
|
| |
| def _write_claim(self, run_id: str) -> None: |
| rec = {"run_id": run_id, "account": self.account, |
| "session": self.session_id, "claimed_at": now_iso(), |
| "epoch_s": time.time(), "host": os.uname().nodename |
| if hasattr(os, "uname") else "?"} |
| p = self._tmp / f"claim_{self.ns.strip('/')}{run_id}.json" |
| atomic_write_json(p, rec) |
| self.store.enqueue(p, self._claim_path(run_id)) |
| self.store.flush(120) |
|
|
| def heartbeat(self, run_id: str) -> None: |
| """Staleness detection depends on this. Called on every push cycle.""" |
| try: |
| self._write_claim(run_id) |
| except Exception as e: |
| print(f"[REGISTRY] heartbeat failed (non-fatal): {e}") |
|
|
| def complete(self, run_id: str, metrics: Dict[str, Any]) -> None: |
| rec = {"run_id": run_id, "account": self.account, |
| "session": self.session_id, "finished_at": now_iso(), |
| **{k: (float(v) if isinstance(v, (int, float)) else str(v)) |
| for k, v in metrics.items()}} |
| p = self._tmp / f"done_{self.ns.strip('/')}{run_id}.json" |
| atomic_write_json(p, rec) |
| self.store.enqueue(p, self._done_path(run_id)) |
| self.store.flush(120) |
| print(f"[REGISTRY] {run_id} marked done") |
|
|
| @staticmethod |
| def plan(run_ids: Sequence[str], n_workers: int) -> Dict[int, List[str]]: |
| """Deal the runs round-robin: worker i gets run_ids[i::n_workers]. |
| |
| With 4 runs and 3 workers this is 2+1+1, which is what you want -- the |
| alternative (contiguous chunks) gives 2+2+0 and leaves a worker idle. |
| |
| This is a *plan*, not an assignment. It exists so you can see up front |
| who is expected to do what. Nothing enforces it: a worker that finishes |
| its share moves on to steal whatever is still outstanding, so a worker |
| that never starts costs wall clock and nothing else. |
| """ |
| n_workers = max(1, int(n_workers)) |
| return {w: list(run_ids[w - 1::n_workers]) |
| for w in range(1, n_workers + 1)} |
|
|
| def show_plan(self, run_ids: Sequence[str], n_workers: int, |
| me: int) -> List[str]: |
| pl = self.plan(run_ids, n_workers) |
| st = self.status(run_ids) |
| print(f"\nPLAN — {len(run_ids)} runs across {n_workers} worker(s) " |
| f"[{'+'.join(str(len(v)) for v in pl.values())}]") |
| print("-" * 78) |
| for w, runs in pl.items(): |
| tag = " <-- THIS NOTEBOOK" if w == me else "" |
| print(f" worker {w}{tag}") |
| for r in runs: |
| print(f" {r:34s} {st[r]['state']}") |
| if not runs: |
| print(" (nothing in its share; it will steal instead)") |
| print("-" * 78) |
| print(" Shares are advisory. Any worker that finishes its own share") |
| print(" steals whatever is still outstanding, so idle workers never") |
| print(" block the queue -- if worker 3 never starts, workers 1 and 2") |
| print(" will pick up its runs automatically.") |
| outstanding = [r for r in run_ids if st[r]["state"] != "done"] |
| print(f" {len(run_ids)-len(outstanding)}/{len(run_ids)} done, " |
| f"{len(outstanding)} outstanding\n") |
| return pl.get(me, []) |
|
|
| def claim_next(self, run_ids: Sequence[str], prefer: Optional[str] = None, |
| force: bool = False, |
| my_share: Optional[Sequence[str]] = None) -> Optional[str]: |
| """Claim one available run. None when there is nothing left to do. |
| |
| `prefer` pins a specific run_id (manual mode). `force` takes it even if |
| someone else holds it -- for when you know the other session is dead |
| and you do not want to wait out the staleness window. |
| """ |
| st = self.status(run_ids) |
|
|
| if prefer: |
| s = st.get(prefer) |
| if s is None: |
| raise ValueError(f"{prefer} is not in the run manifest") |
| if s["state"] == "done" and not force: |
| print(f"[REGISTRY] {prefer} is already done. Nothing to do.") |
| return None |
| if s["state"] == "held" and not force: |
| raise RuntimeError( |
| f"{prefer} is held by account {s.get('by')} " |
| f"({s.get('age_h')} h ago). Set FORCE_CLAIM=True only if " |
| f"you know that session is dead -- two sessions writing the " |
| f"same run will corrupt its checkpoint.") |
| candidates = [prefer] |
| else: |
| free = [r for r in run_ids if st[r]["state"] == "available"] |
| stale = [r for r in run_ids if st[r]["state"] == "stale"] |
| if my_share: |
| |
| |
| |
| mine = set(my_share) |
| free = ([r for r in free if r in mine] + |
| [r for r in free if r not in mine]) |
| stale = ([r for r in stale if r in mine] + |
| [r for r in stale if r not in mine]) |
| candidates = free + stale |
| if not candidates: |
| return None |
|
|
| for rid in candidates: |
| if my_share is not None and rid not in set(my_share) and not prefer: |
| print(f"[REGISTRY] own share exhausted -> STEALING {rid} " |
| f"(it was planned for another worker that has not taken it)") |
| if st.get(rid, {}).get("state") == "stale": |
| print(f"[REGISTRY] taking over stale claim on {rid} " |
| f"({st[rid].get('age_h')} h old) -- resuming from ckpt_last") |
| self._write_claim(rid) |
| |
| time.sleep(random.uniform(3.0, 8.0)) |
| c = self._read(self._claim_path(rid)) or {} |
| if c.get("session") == self.session_id or force: |
| print(f"[REGISTRY] claimed {rid} (account {self.account})") |
| return rid |
| print(f"[REGISTRY] lost race for {rid} to account {c.get('account')}, " |
| f"trying another") |
| return None |
|
|
|
|
| def log_exception(path, stage: str, epoch: int, e: BaseException) -> None: |
| """Failures that were recovered from are still evidence.""" |
| rec = {"at": now_iso(), "stage": stage, "epoch": epoch, |
| "type": type(e).__name__, "msg": str(e), |
| "traceback": traceback.format_exc()[-4000:]} |
| p = Path(path) |
| ensure_dir(p.parent) |
| with open(p, "a", encoding="utf-8") as f: |
| f.write(json.dumps(rec) + "\n") |
|
|
|
|
| |
| |
| |
|
|
| def build_config(run_id: str, arch: str, seed: int, *, |
| dataset: str = "cifar100", epochs: int = 240, |
| batch_size: int = 64, lr: float = 0.05, |
| momentum: float = 0.9, weight_decay: float = 5e-4, |
| milestones: Sequence[int] = (150, 180, 210), |
| gamma: float = 0.1, |
| exit_fractions: Sequence[float] = (0.2, 0.4, 0.6, 0.8, 1.0), |
| resolutions: Sequence[int] = (16, 20, 24, 28, 32), |
| taus: Sequence[float] = (0.0, 0.1, 0.2, 0.3, 0.5), |
| head_seeds: Sequence[int] = (1, 2, 3), |
| head_epochs: int = 20, head_lr: float = 0.01, |
| train_seen_n: int = 5000, |
| el2n_epoch: int = 20, |
| deterministic: bool = True, |
| smoke: bool = False) -> Dict[str, Any]: |
| """The science block is hashed; the runtime block is not. |
| |
| Hashing runtime would make every legitimate resume on a different session |
| fail, and a policy that cries wolf gets disabled by the third day. |
| """ |
| science = { |
| "run_id": run_id, |
| "arch": arch, |
| "dataset": dataset, |
| "seed": int(seed), |
| "epochs": int(epochs), |
| "batch_size": int(batch_size), |
| "lr": float(lr), |
| "momentum": float(momentum), |
| "weight_decay": float(weight_decay), |
| "milestones": [int(m) for m in milestones], |
| "gamma": float(gamma), |
| "augment": "randomcrop32_pad4 + hflip", |
| "normalize_mean": [0.5071, 0.4865, 0.4409], |
| "normalize_std": [0.2673, 0.2564, 0.2762], |
| "exit_fractions": [float(f) for f in exit_fractions], |
| "resolutions": [int(r) for r in resolutions], |
| "resolution_primary": "native", |
| "taus": [float(t) for t in taus], |
| "head_seeds": [int(s) for s in head_seeds], |
| "head_epochs": int(head_epochs), |
| "head_lr": float(head_lr), |
| "head_augment": False, |
| "train_seen_n": int(train_seen_n), |
| "el2n_epoch": int(el2n_epoch), |
| "model_of_record": "ckpt_last", |
| "smoke": bool(smoke), |
| "lib_version": __version__, |
| } |
| runtime = { |
| "account_index": 0, |
| "push_interval_min": 20, |
| "session_budget_h": 8.5, |
| "num_workers": 2, |
| "amp": True, |
| "deterministic": bool(deterministic), |
| "work_dir": "/kaggle/working", |
| "scratch_dir": "/kaggle/temp", |
| "force_claim": False, |
| "force_config_override": False, |
| "fast_data": True, |
| "show_progress": True, |
| } |
| return {"science": science, "runtime": runtime} |
|
|
|
|
| def config_hash(cfg: Dict[str, Any]) -> str: |
| return sha256_bytes(canonical_json(cfg["science"]).encode()) |
|
|
|
|
| class ConfigDriftError(RuntimeError): |
| pass |
|
|
|
|
| def assert_config_hash(cfg: Dict[str, Any], ckpt: Dict[str, Any]) -> None: |
| """Fail loudly on mismatch. Silently resuming under an edited config is |
| worse than crashing.""" |
| want = config_hash(cfg) |
| got = ckpt.get("config_hash") |
| if got == want: |
| return |
| if cfg["runtime"].get("force_config_override"): |
| print(f"[CONFIG] !! OVERRIDE: hash {got} != {want}. " |
| f"Run will be permanently marked config_override=true.") |
| return |
| raise ConfigDriftError( |
| f"config_hash mismatch.\n checkpoint: {got}\n current: {want}\n" |
| f"The science block has changed since this run started. Either restore " |
| f"the original config, or set runtime.force_config_override=True to " |
| f"resume anyway (the run will be permanently flagged)." |
| ) |
|
|
|
|
| ACCURACY_GATE = { |
| |
| "resnet32x4": (79.42, 78.40, 79.00), |
| "wrn40x2": (75.61, 74.60, 75.20), |
| } |
|
|
|
|
| |
| |
| |
|
|
| CIFAR100_MEAN = (0.5071, 0.4865, 0.4409) |
| CIFAR100_STD = (0.2673, 0.2564, 0.2762) |
|
|
|
|
| |
| |
| |
| |
| |
| |
| KAGGLE_DATASETS = { |
| "cifar100": "shanmuk4622/dataset-cifar100-python", |
| "cifar10": "shanmuk4622/dataset-cifar10-python", |
| } |
| _PICKLE_DIRNAME = {"cifar100": "cifar-100-python", "cifar10": "cifar-10-batches-py"} |
| _PICKLE_FILES = {"cifar100": ("train", "test"), |
| "cifar10": ("data_batch_1", "test_batch")} |
|
|
|
|
| def _is_pickle_root(p: Path, which: str) -> bool: |
| """True if p DIRECTLY contains the split files (no nesting).""" |
| return p.is_dir() and all((p / f).exists() for f in _PICKLE_FILES[which]) |
|
|
|
|
| def _find_pickle_root(base: Path, which: str, depth: int = 3) -> Optional[Path]: |
| """Locate the directory holding the split files, whatever the nesting. |
| |
| Kaggle datasets preserve whatever the uploader zipped, so all three of |
| these are possible and all three must work: |
| <base>/cifar-100-python/train |
| <base>/train |
| <base>/anything/cifar-100-python/train |
| """ |
| if not base.exists(): |
| return None |
| if _is_pickle_root(base, which): |
| return base |
| cand = base / _PICKLE_DIRNAME[which] |
| if _is_pickle_root(cand, which): |
| return cand |
| try: |
| for p in base.rglob("*"): |
| if p.is_dir() and len(p.relative_to(base).parts) <= depth \ |
| and _is_pickle_root(p, which): |
| return p |
| except Exception: |
| pass |
| return None |
|
|
|
|
| def _extract_any_tarball(base: Path, which: str, scratch: Path) -> Optional[Path]: |
| """Some uploads keep the .tar.gz. Extract to scratch, never to |
| /kaggle/working -- that is 20 GB and it is the artifact space.""" |
| import tarfile |
| if not base.exists(): |
| return None |
| for tb in list(base.glob("*.tar.gz")) + list(base.glob("*.tgz")): |
| dest = ensure_dir(scratch / "data") |
| print(f"[DATA] extracting {tb.name} -> {dest}") |
| try: |
| with tarfile.open(tb) as t: |
| t.extractall(dest) |
| except Exception as e: |
| print(f"[DATA] extract failed: {e}") |
| continue |
| r = _find_pickle_root(dest, which) |
| if r is not None: |
| return r |
| return None |
|
|
|
|
| def locate_cifar(which: str = "cifar100", |
| scratch_dir: str = "/kaggle/temp") -> str: |
| """Return the directory that DIRECTLY contains the CIFAR pickle splits. |
| |
| Resolution order, fastest first: |
| 1. An attached Kaggle dataset (no download at all). |
| 2. kagglehub download of the team mirror -- public, inside Kaggle, fast. |
| 3. A tarball in any attached dataset, extracted to scratch. |
| 4. torchvision download from cs.toronto.edu (last resort, slowest). |
| |
| Whichever path wins, dataset_fingerprint() is asserted against the value |
| frozen at bootstrap, so a changed source cannot silently repermute |
| sample_idx. |
| """ |
| assert which in KAGGLE_DATASETS, f"unknown dataset {which}" |
| scratch = Path(scratch_dir) |
| slug = KAGGLE_DATASETS[which] |
| short = slug.split("/")[-1] |
|
|
| |
| inp = Path("/kaggle/input") |
| for base in [inp / short, inp / short.replace("dataset-", ""), |
| inp / _PICKLE_DIRNAME[which]]: |
| r = _find_pickle_root(base, which) |
| if r is not None: |
| print(f"[DATA] attached Kaggle dataset: {r}") |
| return str(r) |
| if inp.exists(): |
| for base in sorted(inp.iterdir()): |
| r = _find_pickle_root(base, which) |
| if r is not None: |
| print(f"[DATA] attached Kaggle dataset: {r}") |
| return str(r) |
|
|
| |
| try: |
| import kagglehub |
| print(f"[DATA] kagglehub download: {slug}") |
| p = Path(kagglehub.dataset_download(slug)) |
| r = _find_pickle_root(p, which) or _extract_any_tarball(p, which, scratch) |
| if r is not None: |
| print(f"[DATA] kagglehub -> {r}") |
| return str(r) |
| print(f"[DATA] kagglehub returned {p} but no pickle splits inside") |
| except Exception as e: |
| print(f"[DATA] kagglehub unavailable ({type(e).__name__}: {e})") |
|
|
| |
| if inp.exists(): |
| for base in sorted(inp.iterdir()): |
| r = _extract_any_tarball(base, which, scratch) |
| if r is not None: |
| return str(r) |
|
|
| |
| r = _find_pickle_root(scratch / "data", which) |
| if r is not None: |
| print(f"[DATA] cached in scratch: {r}") |
| return str(r) |
|
|
| |
| root = ensure_dir(scratch / "data") |
| print(f"[DATA] falling back to torchvision download of {which} " |
| f"(slower; prefer attaching {slug})") |
| from torchvision import datasets |
| ds = datasets.CIFAR100 if which == "cifar100" else datasets.CIFAR10 |
| ds(root=str(root), train=True, download=True) |
| ds(root=str(root), train=False, download=True) |
| r = _find_pickle_root(root, which) |
| assert r is not None, f"{which} download did not produce the pickle splits" |
| return str(r) |
|
|
|
|
| def locate_cifar100(scratch_dir: str = "/kaggle/temp") -> str: |
| """Back-compat alias. Phase 0 is CIFAR-100 only.""" |
| return locate_cifar("cifar100", scratch_dir) |
|
|
|
|
| def _load_cifar100_raw(root: str, train: bool) -> Tuple[np.ndarray, np.ndarray]: |
| """Load straight from the pickle so the ordering is canonically defined. |
| |
| `root` DIRECTLY contains `train` and `test` -- locate_cifar() has already |
| resolved whatever nesting the Kaggle upload happened to use. |
| """ |
| f = Path(root) / ("train" if train else "test") |
| if not f.exists(): |
| alt = Path(root) / "cifar-100-python" / ("train" if train else "test") |
| if alt.exists(): |
| f = alt |
| with open(f, "rb") as fh: |
| d = pickle.load(fh, encoding="bytes") |
| data = d[b"data"].reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1) |
| labels = np.array(d[b"fine_labels"], dtype=np.int64) |
| return np.ascontiguousarray(data), labels |
|
|
|
|
| def dataset_fingerprint(root: str) -> Dict[str, str]: |
| """sha256 over labels and the leading image bytes, both splits. |
| |
| Asserted equal across all four runs at analysis time. Catches a swapped |
| mirror, a re-uploaded dataset, and a torchvision version change -- any of |
| which would silently repermute sample_idx. |
| """ |
| fp = {} |
| for split, train in (("train", True), ("test", False)): |
| data, labels = _load_cifar100_raw(root, train) |
| fp[f"{split}_n"] = str(len(labels)) |
| fp[f"{split}_labels_sha256"] = sha256_bytes(labels.astype(np.uint8).tobytes()) |
| fp[f"{split}_pixels_sha256"] = sha256_bytes(data[:100].tobytes()) |
| return fp |
|
|
|
|
| class CIFAR100Tensor: |
| """In-memory uint8 dataset. Order is the pickle order, always. |
| |
| Augmentation is applied on the fly and consumes the per-worker torch RNG, |
| so it is captured by the checkpoint's RNG state. |
| """ |
|
|
| def __init__(self, root: str, train: bool, augment: bool, |
| indices: Optional[np.ndarray] = None): |
| data, labels = _load_cifar100_raw(root, train) |
| self.all_idx = np.arange(len(labels)) if indices is None else np.asarray(indices) |
| self.data = torch.from_numpy(data[self.all_idx]).permute(0, 3, 1, 2).contiguous() |
| self.labels = torch.from_numpy(labels[self.all_idx]) |
| self.augment = augment |
| self.mean = torch.tensor(CIFAR100_MEAN).view(3, 1, 1) |
| self.std = torch.tensor(CIFAR100_STD).view(3, 1, 1) |
|
|
| def __len__(self) -> int: |
| return len(self.labels) |
|
|
| def __getitem__(self, i: int): |
| img = self.data[i] |
| if self.augment: |
| |
| |
| img = F.pad(img.unsqueeze(0), (4, 4, 4, 4), mode="constant", |
| value=0).squeeze(0) |
| top = int(torch.randint(0, 9, (1,)).item()) |
| left = int(torch.randint(0, 9, (1,)).item()) |
| img = img[:, top:top + 32, left:left + 32] |
| if torch.rand(1).item() < 0.5: |
| img = torch.flip(img, dims=[2]) |
| x = img.float().div_(255.0).sub_(self.mean).div_(self.std) |
| return x, self.labels[i], int(self.all_idx[i]) |
|
|
|
|
| def build_loaders(cfg: Dict[str, Any], root: str, device=None, |
| fast_gpu: bool = True): |
| """Train loader is shuffled with an explicit, seeded generator. |
| EVERY eval loader is shuffle=False, drop_last=False, sampler=None -- |
| the canonical ordering that sample_idx refers to.""" |
| from torch.utils.data import DataLoader |
| sci, rt = cfg["science"], cfg["runtime"] |
| seed = sci["seed"] |
| nw = int(rt.get("num_workers", 2)) |
|
|
| n_train = 500 if sci["smoke"] else None |
| n_test = 500 if sci["smoke"] else None |
| tr_idx = np.arange(n_train) if n_train else None |
| te_idx = np.arange(n_test) if n_test else None |
|
|
| train_ds = CIFAR100Tensor(root, True, augment=True, indices=tr_idx) |
| train_eval_ds = CIFAR100Tensor(root, True, augment=False, indices=tr_idx) |
| test_ds = CIFAR100Tensor(root, False, augment=False, indices=te_idx) |
|
|
| g = torch.Generator() |
| g.manual_seed(derive_seed(seed, "dataloader_shuffle")) |
|
|
| common = dict(num_workers=nw, pin_memory=True, |
| persistent_workers=bool(nw), ) |
| if nw: |
| common["prefetch_factor"] = 4 |
| common["worker_init_fn"] = worker_init_fn_factory( |
| derive_seed(seed, "worker")) |
|
|
| gpu_ds = None |
| if fast_gpu and device is not None and getattr(device, "type", "") == "cuda": |
| try: |
| gpu_ds = GPUCifar(root, True, device, indices=tr_idx) |
| print(f"[DATA] GPU-resident training set: {len(gpu_ds)} images, " |
| f"{gpu_ds.x.numel()/1e6:.0f} MB uint8 on device " |
| f"(dataloader removed from the critical path)") |
| except Exception as e: |
| print(f"[DATA] GPU pipeline unavailable ({e}); using DataLoader") |
| gpu_ds = None |
|
|
| train_loader = DataLoader(train_ds, batch_size=sci["batch_size"], |
| shuffle=True, drop_last=False, generator=g, |
| **common) |
| eval_common = dict(num_workers=nw, pin_memory=True, |
| persistent_workers=bool(nw)) |
| if nw: |
| eval_common["prefetch_factor"] = 4 |
| train_eval_loader = DataLoader(train_eval_ds, batch_size=256, shuffle=False, |
| drop_last=False, sampler=None, **eval_common) |
| test_loader = DataLoader(test_ds, batch_size=256, shuffle=False, |
| drop_last=False, sampler=None, **eval_common) |
| return train_loader, train_eval_loader, test_loader, gpu_ds |
|
|
|
|
| class GPUCifar: |
| """The whole dataset resident on the GPU as uint8, augmented in batch. |
| |
| Why this exists: CIFAR ResNets at batch 64 are *latency* bound, not compute |
| bound. resnet32x4 is ~1.09 GMACs, so a batch takes single-digit ms on a T4 -- |
| but a Python DataLoader doing per-sample pad/crop/flip/normalise on 2 Kaggle |
| vCPUs cannot keep up, and the GPU spends most of the epoch waiting. Moving |
| the 150 MB of uint8 pixels onto the card removes the dataloader from the |
| critical path entirely. |
| |
| Semantics are matched to torchvision EXACTLY, not approximately: |
| RandomCrop(32, padding=4) -> zero-pad in [0,255] uint8 space, THEN crop. |
| (Padding before normalisation matters: zero in pixel space is NOT |
| zero after Normalize, so padding a normalised tensor would train on |
| different data.) |
| RandomHorizontalFlip(p=0.5) |
| ToTensor -> /255 |
| Normalize(mean, std) |
| |
| verify_msc_lib.py section 15 asserts pixel-exact agreement with the |
| torchvision ops for fixed (top, left, flip), so this is a speed change and |
| not a recipe change. |
| |
| Augmentation draws from the torch CUDA RNG, so it is captured by the |
| checkpoint's RNG state and a resumed run sees the same augmentations. |
| """ |
|
|
| def __init__(self, root: str, train: bool, device, indices=None): |
| data, labels = _load_cifar100_raw(root, train) |
| idx = np.arange(len(labels)) if indices is None else np.asarray(indices) |
| self.sample_idx = torch.from_numpy(idx.astype(np.int64)).to(device) |
| self.x = torch.from_numpy(data[idx]).permute(0, 3, 1, 2).contiguous().to(device) |
| self.y = torch.from_numpy(labels[idx]).to(device) |
| self.device = device |
| self.n = len(idx) |
| self.mean = torch.tensor(CIFAR100_MEAN, device=device).view(1, 3, 1, 1) * 255.0 |
| self.std = torch.tensor(CIFAR100_STD, device=device).view(1, 3, 1, 1) * 255.0 |
| self._padded = None |
|
|
| def __len__(self) -> int: |
| return self.n |
|
|
| def _norm(self, xb: torch.Tensor) -> torch.Tensor: |
| return (xb.float() - self.mean) / self.std |
|
|
| def augment(self, xb_u8: torch.Tensor, gen=None) -> torch.Tensor: |
| """Batched RandomCrop(32, pad=4) + RandomHorizontalFlip, on GPU.""" |
| b = xb_u8.shape[0] |
| xp = F.pad(xb_u8, (4, 4, 4, 4), mode="constant", value=0) |
| top = torch.randint(0, 9, (b,), device=self.device, generator=gen) |
| left = torch.randint(0, 9, (b,), device=self.device, generator=gen) |
| ar = torch.arange(32, device=self.device) |
| r = (top.view(b, 1) + ar.view(1, 32)).view(b, 1, 32, 1).expand(b, 3, 32, 40) |
| xp = xp.gather(2, r) |
| c = (left.view(b, 1) + ar.view(1, 32)).view(b, 1, 1, 32).expand(b, 3, 32, 32) |
| xp = xp.gather(3, c) |
| flip = torch.rand(b, device=self.device, generator=gen) < 0.5 |
| xp = torch.where(flip.view(b, 1, 1, 1), xp.flip(3), xp) |
| return self._norm(xp) |
|
|
| def train_batches(self, batch_size: int, gen=None): |
| perm = torch.randperm(self.n, device=self.device, generator=gen) |
| for i in range(0, self.n, batch_size): |
| sl = perm[i:i + batch_size] |
| yield self.augment(self.x[sl], gen), self.y[sl], self.sample_idx[sl] |
|
|
| def eval_batches(self, batch_size: int = 512, resolution: int = 32, |
| mode: str = "native"): |
| """Deterministic order, no augmentation. THIS is the canonical |
| sample_idx ordering that every per-sample table refers to.""" |
| for i in range(0, self.n, batch_size): |
| xb = self._norm(self.x[i:i + batch_size]) |
| if resolution != 32: |
| xb = F.interpolate(xb, size=(resolution, resolution), |
| mode="bilinear", align_corners=False) |
| if mode == "upsample": |
| xb = F.interpolate(xb, size=(32, 32), mode="bilinear", |
| align_corners=False) |
| yield xb, self.y[i:i + batch_size], self.sample_idx[i:i + batch_size] |
|
|
| def n_batches(self, batch_size: int) -> int: |
| return (self.n + batch_size - 1) // batch_size |
|
|
|
|
| def make_progress(total: int, desc: str, enable: bool = True): |
| """tqdm if available, otherwise a dependency-free fallback bar.""" |
| if not enable: |
| class _Null: |
| def update(self, n=1): pass |
| def set_postfix_str(self, s): pass |
| def close(self): pass |
| return _Null() |
| try: |
| from tqdm.auto import tqdm |
| return tqdm(total=total, desc=desc, leave=False, dynamic_ncols=True, |
| mininterval=0.5) |
| except Exception: |
| class _Bar: |
| def __init__(s, total, desc): |
| s.total, s.desc, s.i, s.t0 = total, desc, 0, time.time() |
| s.post = "" |
| def update(s, n=1): |
| s.i += n |
| if s.i % max(1, s.total // 40) and s.i != s.total: |
| return |
| frac = s.i / max(s.total, 1) |
| done = int(30 * frac) |
| el = time.time() - s.t0 |
| eta = el / max(frac, 1e-9) - el |
| sys.stdout.write(f"\r {s.desc} |{'#'*done}{'.'*(30-done)}| " |
| f"{s.i}/{s.total} {el:5.1f}s eta {eta:5.1f}s {s.post}") |
| sys.stdout.flush() |
| def set_postfix_str(s, t): s.post = t |
| def close(s): |
| sys.stdout.write("\r" + " " * 110 + "\r") |
| sys.stdout.flush() |
| return _Bar(total, desc) |
|
|
|
|
| def frozen_train_slice(n_total: int, n_slice: int, master_seed: int = 0) -> List[int]: |
| """A fixed 5,000-index slice of the TRAINING set that IS trained on. |
| |
| Identical across all four runs. Note: trained on, not held out -- EL2N, |
| forgetting events and prediction depth are only defined on training |
| examples, and holding 5,000 out would cost ~0.5-1 point of test accuracy |
| and risk tripping the accuracy gate for a reason unrelated to the recipe. |
| """ |
| rng = np.random.default_rng(derive_seed(master_seed, "train_seen_slice")) |
| return sorted(rng.choice(n_total, size=min(n_slice, n_total), |
| replace=False).tolist()) |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| class _BasicBlock(nn.Module): |
| expansion = 1 |
|
|
| def __init__(self, inplanes, planes, stride=1, downsample=None): |
| super().__init__() |
| self.conv1 = nn.Conv2d(inplanes, planes, 3, stride, 1, bias=False) |
| self.bn1 = nn.BatchNorm2d(planes) |
| self.relu = nn.ReLU(inplace=True) |
| self.conv2 = nn.Conv2d(planes, planes, 3, 1, 1, bias=False) |
| self.bn2 = nn.BatchNorm2d(planes) |
| self.downsample = downsample |
|
|
| def forward(self, x): |
| residual = x if self.downsample is None else self.downsample(x) |
| out = self.relu(self.bn1(self.conv1(x))) |
| out = self.bn2(self.conv2(out)) |
| return F.relu(out + residual) |
|
|
|
|
| class ResNetCifar(nn.Module): |
| """resnet32x4 = ResNetCifar(32, [32, 64, 128, 256]). |
| |
| depth 32 -> n = (32-2)//6 = 5 blocks per stage, 15 blocks total. |
| """ |
|
|
| def __init__(self, depth: int, num_filters: Sequence[int], |
| num_classes: int = 100): |
| super().__init__() |
| assert (depth - 2) % 6 == 0 |
| n = (depth - 2) // 6 |
| self.inplanes = num_filters[0] |
| self.conv1 = nn.Conv2d(3, num_filters[0], 3, padding=1, bias=False) |
| self.bn1 = nn.BatchNorm2d(num_filters[0]) |
| self.relu = nn.ReLU(inplace=True) |
| self.layer1 = self._make_layer(num_filters[1], n, 1) |
| self.layer2 = self._make_layer(num_filters[2], n, 2) |
| self.layer3 = self._make_layer(num_filters[3], n, 2) |
| self.avgpool = nn.AdaptiveAvgPool2d(1) |
| self.fc = nn.Linear(num_filters[3], num_classes) |
| self.preact = False |
| for m in self.modules(): |
| if isinstance(m, nn.Conv2d): |
| nn.init.kaiming_normal_(m.weight, mode="fan_out", |
| nonlinearity="relu") |
| elif isinstance(m, nn.BatchNorm2d): |
| nn.init.constant_(m.weight, 1) |
| nn.init.constant_(m.bias, 0) |
|
|
| def _make_layer(self, planes, blocks, stride): |
| downsample = None |
| if stride != 1 or self.inplanes != planes: |
| downsample = nn.Sequential( |
| nn.Conv2d(self.inplanes, planes, 1, stride, bias=False), |
| nn.BatchNorm2d(planes)) |
| layers = [_BasicBlock(self.inplanes, planes, stride, downsample)] |
| self.inplanes = planes |
| layers += [_BasicBlock(planes, planes) for _ in range(1, blocks)] |
| return nn.Sequential(*layers) |
|
|
| def blocks(self) -> List[nn.Module]: |
| return list(self.layer1) + list(self.layer2) + list(self.layer3) |
|
|
| def stem(self, x): |
| return self.relu(self.bn1(self.conv1(x))) |
|
|
| def head_from(self, feat): |
| """The model's own classifier. Exit K uses this verbatim.""" |
| return self.fc(self.avgpool(feat).flatten(1)) |
|
|
| def forward(self, x): |
| f = self.stem(x) |
| for b in self.blocks(): |
| f = b(f) |
| return self.head_from(f) |
|
|
|
|
| class _WideBasic(nn.Module): |
| """Pre-activation block, as in the WRN reference implementation.""" |
|
|
| def __init__(self, in_planes, out_planes, stride): |
| super().__init__() |
| self.bn1 = nn.BatchNorm2d(in_planes) |
| self.relu1 = nn.ReLU(inplace=True) |
| self.conv1 = nn.Conv2d(in_planes, out_planes, 3, stride, 1, bias=False) |
| self.bn2 = nn.BatchNorm2d(out_planes) |
| self.relu2 = nn.ReLU(inplace=True) |
| self.conv2 = nn.Conv2d(out_planes, out_planes, 3, 1, 1, bias=False) |
| self.equalInOut = (in_planes == out_planes and stride == 1) |
| self.convShortcut = None if self.equalInOut else nn.Conv2d( |
| in_planes, out_planes, 1, stride, 0, bias=False) |
|
|
| def forward(self, x): |
| if not self.equalInOut: |
| x = self.relu1(self.bn1(x)) |
| out = self.relu2(self.bn2(self.conv1(x))) |
| else: |
| out = self.relu1(self.bn1(x)) |
| out = self.relu2(self.bn2(self.conv1(out))) |
| out = self.conv2(out) |
| return out + (x if self.equalInOut else self.convShortcut(x)) |
|
|
|
|
| class WideResNet(nn.Module): |
| """wrn-40-2 = WideResNet(40, 2). n = (40-4)//6 = 6 -> 18 blocks.""" |
|
|
| def __init__(self, depth: int, widen: int, num_classes: int = 100): |
| super().__init__() |
| assert (depth - 4) % 6 == 0 |
| n = (depth - 4) // 6 |
| ch = [16, 16 * widen, 32 * widen, 64 * widen] |
| self.conv1 = nn.Conv2d(3, ch[0], 3, 1, 1, bias=False) |
| self.block1 = self._make(ch[0], ch[1], n, 1) |
| self.block2 = self._make(ch[1], ch[2], n, 2) |
| self.block3 = self._make(ch[2], ch[3], n, 2) |
| self.bn1 = nn.BatchNorm2d(ch[3]) |
| self.relu = nn.ReLU(inplace=True) |
| self.avgpool = nn.AdaptiveAvgPool2d(1) |
| self.fc = nn.Linear(ch[3], num_classes) |
| self.preact = True |
| for m in self.modules(): |
| if isinstance(m, nn.Conv2d): |
| nn.init.kaiming_normal_(m.weight, mode="fan_out", |
| nonlinearity="relu") |
| elif isinstance(m, nn.BatchNorm2d): |
| nn.init.constant_(m.weight, 1) |
| nn.init.constant_(m.bias, 0) |
| elif isinstance(m, nn.Linear): |
| nn.init.constant_(m.bias, 0) |
|
|
| @staticmethod |
| def _make(inp, outp, n, stride): |
| return nn.Sequential(*[ |
| _WideBasic(inp if i == 0 else outp, outp, stride if i == 0 else 1) |
| for i in range(n)]) |
|
|
| def blocks(self) -> List[nn.Module]: |
| return list(self.block1) + list(self.block2) + list(self.block3) |
|
|
| def stem(self, x): |
| return self.conv1(x) |
|
|
| def head_from(self, feat): |
| return self.fc(self.avgpool(self.relu(self.bn1(feat))).flatten(1)) |
|
|
| def forward(self, x): |
| f = self.stem(x) |
| for b in self.blocks(): |
| f = b(f) |
| return self.head_from(f) |
|
|
|
|
| def build_model(arch: str, num_classes: int = 100) -> nn.Module: |
| if arch == "resnet32x4": |
| return ResNetCifar(32, [32, 64, 128, 256], num_classes) |
| if arch == "wrn40x2": |
| return WideResNet(40, 2, num_classes) |
| raise ValueError(f"unknown arch {arch}") |
|
|
|
|
| def exit_block_indices(model: nn.Module, fractions: Sequence[float]) -> List[int]: |
| """round(frac * n_blocks), minimum 1. Documented rounding rule.""" |
| n = len(model.blocks()) |
| idx = [max(1, int(round(f * n))) for f in fractions] |
| assert idx[-1] == n, f"last exit must be the full backbone: {idx[-1]} != {n}" |
| assert all(a < b for a, b in zip(idx, idx[1:])), f"exits not strictly increasing: {idx}" |
| return idx |
|
|
|
|
| @torch.no_grad() |
| def exit_channels(model: nn.Module, block_idx: Sequence[int], |
| device="cpu") -> List[int]: |
| model.eval() |
| x = torch.zeros(2, 3, 32, 32, device=device) |
| f = model.stem(x) |
| chans, want = [], set(block_idx) |
| for i, b in enumerate(model.blocks(), start=1): |
| f = b(f) |
| if i in want: |
| chans.append(int(f.shape[1])) |
| return chans |
|
|
|
|
| def measure_budgets(model: nn.Module, block_idx: Sequence[int], |
| resolutions: Sequence[int]) -> Dict[str, Any]: |
| """Measured FLOPs per configuration, not assumed. |
| |
| Stage FLOPs are near-equal by design in these architectures, but 'near' is |
| not 'is', and Q2's PCA reads raw rho values. Falls back to an analytic |
| conv-MAC count if fvcore/ptflops are unavailable. |
| """ |
| device = next(model.parameters()).device |
| model.eval() |
| n_blocks = len(model.blocks()) |
| num_classes = model.fc.out_features |
|
|
| def flops_prefix(k: int, res: int) -> float: |
| """MACs for stem + blocks[1..k] + the head that reads exit k. |
| |
| The head at k < K is the *exit probe* (pool -> BN1d -> Linear over the |
| channels present at that depth), NOT the model's final classifier. |
| Calling model.head_from() on an intermediate feature map is a shape |
| error -- block 3 of resnet32x4 emits 64 channels into a Linear(256,100) |
| -- and, more importantly, it would be the wrong cost: exit k is priced |
| with the head that is actually attached to it. |
| """ |
| total = [0.0] |
| hooks = [] |
|
|
| def hook(m, inp, out): |
| if isinstance(m, nn.Conv2d): |
| total[0] += (m.in_channels / m.groups) * m.out_channels * \ |
| m.kernel_size[0] * m.kernel_size[1] * out.shape[2] * out.shape[3] |
| elif isinstance(m, nn.Linear): |
| total[0] += m.in_features * m.out_features |
| for mod in model.modules(): |
| if isinstance(mod, (nn.Conv2d, nn.Linear)): |
| hooks.append(mod.register_forward_hook(hook)) |
| head_macs = 0.0 |
| with torch.no_grad(): |
| x = torch.zeros(1, 3, res, res, device=device) |
| f = model.stem(x) |
| for i, b in enumerate(model.blocks(), start=1): |
| if i > k: |
| break |
| f = b(f) |
| if k >= n_blocks: |
| _ = model.head_from(f) |
| else: |
| head_macs = float(f.shape[1]) * num_classes |
| for h in hooks: |
| h.remove() |
| return total[0] + head_macs |
|
|
| full32 = flops_prefix(len(model.blocks()), 32) |
| depth = [flops_prefix(k, 32) for k in block_idx] |
| res = [flops_prefix(len(model.blocks()), r) for r in resolutions] |
| out = { |
| "flops_full_32px": full32, |
| "depth_block_idx": list(map(int, block_idx)), |
| "depth_flops": depth, |
| "rho_depth": [f / full32 for f in depth], |
| "resolutions": list(map(int, resolutions)), |
| "resolution_flops": res, |
| "rho_resolution": [f / full32 for f in res], |
| "rho_resolution_analytic": [(r / 32.0) ** 2 for r in resolutions], |
| "note": "MACs counted by forward hooks on Conv2d/Linear; head cost included.", |
| } |
| for key in ("rho_depth", "rho_resolution"): |
| v = out[key] |
| assert abs(v[-1] - 1.0) < 1e-6, f"{key}[-1] must be 1.0, got {v[-1]}" |
| assert all(a < b for a, b in zip(v, v[1:])), f"{key} not ascending: {v}" |
| return out |
|
|
|
|
| |
| |
| |
|
|
| class ExitHead(nn.Module): |
| """pool -> BN -> linear. Deliberately small. |
| |
| A heavier head would do its own representation learning, which confounds |
| the measurement: we want to read what the backbone has computed by this |
| depth, not what a capable head can recover from it. |
| """ |
|
|
| def __init__(self, in_channels: int, num_classes: int): |
| super().__init__() |
| self.norm = nn.BatchNorm1d(in_channels) |
| self.fc = nn.Linear(in_channels, num_classes) |
|
|
| def forward(self, pooled: torch.Tensor) -> torch.Tensor: |
| return self.fc(self.norm(pooled)) |
|
|
|
|
| def backbone_hash(model: nn.Module) -> str: |
| """sha256 over parameters AND buffers. |
| |
| Buffers are where BatchNorm running statistics live. A parameter-only |
| comparison would miss BN drift, which is precisely the failure mode |
| requires_grad=False does not prevent. |
| """ |
| h = hashlib.sha256() |
| for k, v in sorted(model.state_dict().items()): |
| h.update(k.encode()) |
| h.update(np.ascontiguousarray(v.detach().cpu().numpy()).tobytes()) |
| return h.hexdigest() |
|
|
|
|
| @torch.no_grad() |
| def cache_pooled_features(model: nn.Module, loader, block_idx: Sequence[int], |
| device, out_path) -> Dict[str, Any]: |
| """One pass over the data, storing globally-pooled features at each exit. |
| |
| This is the strongest possible freeze: after caching, the backbone is not |
| in the training graph at all. It also makes head training a seconds-long |
| linear+BN fit rather than a 15-minute pass, which is what makes three head |
| seeds free. |
| |
| No augmentation -- these are probes measuring a representation, not |
| deployed classifiers. |
| """ |
| model.eval() |
| want = set(block_idx) |
| feats: Dict[int, List[torch.Tensor]] = {k: [] for k in block_idx} |
| labels, idxs = [], [] |
| for x, y, si in loader: |
| x = x.to(device, non_blocking=True) |
| f = model.stem(x) |
| for i, b in enumerate(model.blocks(), start=1): |
| f = b(f) |
| if i in want: |
| g = model.relu(model.bn1(f)) if getattr(model, "preact", False) \ |
| and i == len(model.blocks()) else f |
| feats[i].append(F.adaptive_avg_pool2d(g, 1).flatten(1).cpu()) |
| labels.append(y.clone()) |
| idxs.append(si.clone() if torch.is_tensor(si) else torch.as_tensor(si)) |
| out = {"block_idx": list(map(int, block_idx)), |
| "labels": torch.cat(labels), |
| "sample_idx": torch.cat(idxs)} |
| for k in block_idx: |
| out[f"feat_{k}"] = torch.cat(feats[k]) |
| ensure_dir(Path(out_path).parent) |
| torch.save(out, out_path) |
| return out |
|
|
|
|
| def train_exit_heads(cached_train: Dict[str, Any], cached_test: Dict[str, Any], |
| block_idx: Sequence[int], num_classes: int, |
| head_seed: int, epochs: int, lr: float, |
| device) -> Dict[int, nn.Module]: |
| """Fit one probe per exit on cached pooled features. |
| |
| Exit K is NOT trained here -- it is the model's own classifier, used |
| verbatim, because compute_msc takes preds[:, -1] as the full-compute |
| reference y*. If that column came from a probe, the reference decision |
| would be the probe's rather than the model's. |
| """ |
| heads: Dict[int, nn.Module] = {} |
| y = cached_train["labels"].to(device) |
| n = y.numel() |
| for k in block_idx[:-1]: |
| set_all_seeds(derive_seed(head_seed, "head", k), deterministic=False) |
| X = cached_train[f"feat_{k}"].to(device) |
| head = ExitHead(X.shape[1], num_classes).to(device) |
| opt = torch.optim.SGD(head.parameters(), lr=lr, momentum=0.9, |
| weight_decay=5e-4) |
| sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs) |
| bs = 256 |
| g = torch.Generator(device="cpu") |
| g.manual_seed(derive_seed(head_seed, "head_shuffle", k)) |
| for _ in range(epochs): |
| head.train() |
| perm = torch.randperm(n, generator=g).to(device) |
| for i in range(0, n, bs): |
| sl = perm[i:i + bs] |
| if sl.numel() < 2: |
| continue |
| opt.zero_grad(set_to_none=True) |
| loss = F.cross_entropy(head(X[sl]), y[sl]) |
| loss.backward() |
| opt.step() |
| sched.step() |
| head.eval() |
| heads[k] = head |
| return heads |
|
|
|
|
| |
| |
| |
|
|
| class EnergyMonitor: |
| """Direct power sampling at >=10 Hz. Reported as methodology, never as a |
| novelty claim. Cumulative joules survive restarts via the checkpoint.""" |
|
|
| def __init__(self, csv_path, hz: float = 10.0): |
| self.csv_path = Path(csv_path) |
| self.dt = 1.0 / hz |
| self._stop = threading.Event() |
| self._thread: Optional[threading.Thread] = None |
| self.joules = 0.0 |
| self._h = None |
|
|
| def start(self, resume_joules: float = 0.0) -> bool: |
| self.joules = float(resume_joules) |
| try: |
| import pynvml |
| pynvml.nvmlInit() |
| self._h = pynvml.nvmlDeviceGetHandleByIndex(0) |
| except Exception as e: |
| print(f"[ENERGY] NVML unavailable ({e}); energy.csv will be empty") |
| return False |
| ensure_dir(self.csv_path.parent) |
| if not self.csv_path.exists(): |
| atomic_write_text(self.csv_path, "time_utc,watts,cum_joules\n") |
| self._stop.clear() |
| self._thread = threading.Thread(target=self._loop, daemon=True, |
| name="nvml") |
| self._thread.start() |
| return True |
|
|
| def _loop(self): |
| import pynvml |
| last = time.time() |
| buf = [] |
| while not self._stop.is_set(): |
| time.sleep(self.dt) |
| try: |
| w = pynvml.nvmlDeviceGetPowerUsage(self._h) / 1000.0 |
| except Exception: |
| continue |
| now = time.time() |
| self.joules += w * (now - last) |
| last = now |
| buf.append(f"{now_iso()},{w:.2f},{self.joules:.1f}\n") |
| if len(buf) >= 100: |
| try: |
| with open(self.csv_path, "a") as f: |
| f.writelines(buf) |
| except Exception: |
| pass |
| buf = [] |
| if buf: |
| try: |
| with open(self.csv_path, "a") as f: |
| f.writelines(buf) |
| except Exception: |
| pass |
|
|
| def stop(self): |
| self._stop.set() |
| if self._thread: |
| self._thread.join(timeout=5) |
| self._thread = None |
|
|
|
|
| |
| |
| |
|
|
| CKPT_REQUIRED = ("run_id", "epoch", "global_step", "model", "optimizer", |
| "scheduler", "scaler", "rng", "best_metric", "config_hash", |
| "wall_seconds", "energy_joules") |
|
|
|
|
| def _schema_check(state: Dict[str, Any]) -> None: |
| """Runs on SAVE as well as load, so an omission is caught the first time |
| rather than at the first resume.""" |
| missing = [k for k in CKPT_REQUIRED if k not in state] |
| if missing: |
| raise RuntimeError(f"checkpoint schema incomplete, missing: {missing}") |
| for k in ("python", "numpy", "torch", "cuda"): |
| if k not in state["rng"]: |
| raise RuntimeError(f"checkpoint rng state missing '{k}'. " |
| f"A resumed run would not equal an uninterrupted " |
| f"one, which makes the seeds meaningless.") |
|
|
|
|
| def save_checkpoint(path, cfg, model, optimizer, scheduler, scaler, |
| epoch: int, global_step: int, best_metric: float, |
| wall_seconds: float, energy_joules: float, |
| extra: Optional[Dict[str, Any]] = None) -> None: |
| state = { |
| "run_id": cfg["science"]["run_id"], |
| "epoch": int(epoch), |
| "global_step": int(global_step), |
| "model": model.state_dict(), |
| "optimizer": optimizer.state_dict(), |
| "scheduler": scheduler.state_dict() if scheduler is not None else None, |
| "scaler": scaler.state_dict() if scaler is not None else None, |
| "rng": rng_state(), |
| "best_metric": float(best_metric), |
| "config_hash": config_hash(cfg), |
| "wall_seconds": float(wall_seconds), |
| "energy_joules": float(energy_joules), |
| "torch_version": torch.__version__, |
| "gpu_name": (torch.cuda.get_device_name(0) |
| if torch.cuda.is_available() else "cpu"), |
| "deterministic": bool(cfg["runtime"].get("deterministic", True)), |
| "saved_at": now_iso(), |
| } |
| if extra: |
| state.update(extra) |
| _schema_check(state) |
| atomic_save_torch(path, state) |
|
|
|
|
| def load_checkpoint(path, cfg, model, optimizer, scheduler, scaler, |
| device, status: Optional[RunStatus] = None |
| ) -> Optional[Dict[str, Any]]: |
| """Returns None if there is nothing to resume from.""" |
| path = Path(path) |
| if not path.exists(): |
| return None |
| try: |
| try: |
| st = torch.load(path, map_location=device, weights_only=False) |
| except TypeError: |
| st = torch.load(path, map_location=device) |
| except Exception as e: |
| print(f"[RESUME] checkpoint at {path} is unreadable: {e}") |
| return None |
| try: |
| _schema_check(st) |
| except Exception as e: |
| print(f"[RESUME] {e}") |
| return None |
|
|
| assert_config_hash(cfg, st) |
|
|
| model.load_state_dict(st["model"], strict=True) |
| if optimizer is not None and st.get("optimizer"): |
| optimizer.load_state_dict(st["optimizer"]) |
| if scheduler is not None and st.get("scheduler"): |
| scheduler.load_state_dict(st["scheduler"]) |
| if scaler is not None and st.get("scaler"): |
| scaler.load_state_dict(st["scaler"]) |
| rng_restore(st["rng"]) |
|
|
| cur_gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu" |
| if st.get("gpu_name") != cur_gpu: |
| msg = f"resumed on {cur_gpu}, started on {st.get('gpu_name')}" |
| print(f"[RESUME] WARNING: {msg}. Bit-exact continuity is void; " |
| f"the run remains scientifically valid.") |
| if status: |
| status.anomaly("gpu_change", msg) |
| if st.get("torch_version") != torch.__version__: |
| msg = f"torch {st.get('torch_version')} -> {torch.__version__}" |
| print(f"[RESUME] WARNING: {msg}") |
| if status: |
| status.anomaly("torch_version_change", msg) |
|
|
| print(f"[RESUME] epoch {st['epoch']} -> continuing at {st['epoch'] + 1}") |
| return st |
|
|
|
|
| def resume_continuity_check(history_csv, resumed_epoch: int, |
| status: Optional[RunStatus] = None) -> None: |
| """Standing guard on every real resume. |
| |
| A resume that restores weights but not RNG produces a perfectly smooth |
| loss curve, so smoothness alone proves nothing -- but a discontinuity |
| definitely proves something is wrong, and it must be surfaced rather than |
| absorbed. |
| """ |
| p = Path(history_csv) |
| if not p.exists(): |
| return |
| try: |
| rows = list(csv.DictReader(open(p))) |
| losses = [float(r["train_loss"]) for r in rows if r.get("train_loss")] |
| except Exception: |
| return |
| if len(losses) < 12: |
| return |
| pre = losses[:resumed_epoch] |
| if len(pre) < 11 or resumed_epoch >= len(losses): |
| return |
| deltas = [abs(pre[i] - pre[i - 1]) for i in range(-10, 0)] |
| med = float(np.median(deltas)) if deltas else 0.0 |
| jump = abs(losses[resumed_epoch] - pre[-1]) |
| if med > 0 and jump > 5 * med: |
| msg = (f"resume jump {jump:.4f} vs median epoch delta {med:.4f} " |
| f"at epoch {resumed_epoch}") |
| if status: |
| status.anomaly("RESUME_ANOMALY", msg) |
| else: |
| print(f"[ANOMALY] {msg}") |
| else: |
| print(f"[RESUME] continuity OK (jump {jump:.4f}, median delta {med:.4f})") |
|
|
|
|
| |
| |
| |
|
|
| class Interrupt: |
| """SIGTERM / SIGINT / atexit -> one immediate full push, then exit. |
| |
| Kaggle sends SIGTERM before killing a session, and catching it buys enough |
| time for a final push. Do NOT rely on it: the grace period is short and a |
| hard kill gives no handlers at all. The 20-minute cadence and the per-epoch |
| local checkpoint are the real guarantee; this is the bonus path. |
| """ |
|
|
| def __init__(self, on_stop: Callable[[str], None]): |
| self.stop_requested = False |
| self.reason = None |
| self._fired = False |
| self._lock = threading.Lock() |
| self._on_stop = on_stop |
| for sig in (signal.SIGTERM, signal.SIGINT): |
| try: |
| signal.signal(sig, self._handle) |
| except Exception: |
| pass |
| atexit.register(self._atexit) |
|
|
| def _handle(self, signum, frame): |
| self.stop_requested = True |
| self.reason = f"signal_{signum}" |
| print(f"\n[SIGNAL] {signum} received -> flushing to HF and stopping") |
| self._fire(self.reason) |
|
|
| def _atexit(self): |
| self._fire("atexit") |
|
|
| def _fire(self, reason: str): |
| |
| |
| with self._lock: |
| if self._fired: |
| return |
| self._fired = True |
| try: |
| self._on_stop(reason) |
| except BaseException as e: |
| print(f"[SIGNAL] final push failed: {e}") |
|
|
|
|
| @torch.no_grad() |
| def evaluate(model, loader, device, amp: bool = True) -> Dict[str, Any]: |
| model.eval() |
| correct = correct5 = total = 0 |
| loss_sum = 0.0 |
| for x, y, _ in loader: |
| x = x.to(device, non_blocking=True) |
| y = y.to(device, non_blocking=True) |
| with torch.autocast("cuda", enabled=amp and device.type == "cuda"): |
| logits = model(x) |
| loss_sum += float(F.cross_entropy(logits.float(), y, reduction="sum")) |
| top5 = logits.topk(min(5, logits.shape[1]), dim=1).indices |
| correct += int((top5[:, 0] == y).sum()) |
| correct5 += int((top5 == y[:, None]).any(1).sum()) |
| total += y.numel() |
| return {"top1": correct / max(total, 1), "top5": correct5 / max(total, 1), |
| "loss": loss_sum / max(total, 1), "n": total} |
|
|
|
|
| @torch.no_grad() |
| def el2n_and_preds(model, loader, device, amp: bool = True): |
| """EL2N = ||softmax(f(x)) - onehot(y)||_2, the during-training variant. |
| |
| NOT GraNd-at-init, which failed reproduction (arXiv 2303.14753). Also |
| returns per-sample correctness, which is what forgetting events count. |
| """ |
| model.eval() |
| el2n, correct, idxs = [], [], [] |
| for x, y, si in loader: |
| x = x.to(device, non_blocking=True) |
| y = y.to(device, non_blocking=True) |
| with torch.autocast("cuda", enabled=amp and device.type == "cuda"): |
| logits = model(x) |
| p = F.softmax(logits.float(), dim=1) |
| oh = F.one_hot(y, p.shape[1]).float() |
| el2n.append(torch.linalg.vector_norm(p - oh, dim=1).cpu()) |
| correct.append((p.argmax(1) == y).cpu()) |
| idxs.append(si.clone() if torch.is_tensor(si) else torch.as_tensor(si)) |
| return (torch.cat(el2n).numpy(), torch.cat(correct).numpy().astype(bool), |
| torch.cat(idxs).numpy()) |
|
|
|
|
| def accuracy_gate(arch: str, top1_pct: float, gate_path, |
| smoke: bool = False) -> Dict[str, Any]: |
| """Hard gate between training and the oracle sweep. It raises. |
| |
| MSC computed from an undertrained model is meaningless, and discovering |
| that in week 3 is exactly what Phase 0 exists to prevent. |
| """ |
| published, halt, warn = ACCURACY_GATE[arch] |
| if smoke: |
| halt, warn = 0.5, 1.0 |
| res = {"arch": arch, "top1_pct": float(top1_pct), "published": published, |
| "halt_below": halt, "warn_below": warn, |
| "margin_vs_published": float(top1_pct - published), |
| "passed": bool(top1_pct >= halt), |
| "warned": bool(top1_pct < warn), "smoke": smoke, "at": now_iso()} |
| atomic_write_json(gate_path, res) |
| if not res["passed"]: |
| raise RuntimeError( |
| f"ACCURACY GATE FAILED: {arch} reached {top1_pct:.2f}% " |
| f"(HALT below {halt}%, published {published}%). " |
| f"Fix the training recipe before generating any MSC table.") |
| if res["warned"]: |
| print(f"[GATE] WARNING: {arch} {top1_pct:.2f}% is below the " |
| f"{warn}% warn line (published {published}%)") |
| else: |
| print(f"[GATE] PASS: {arch} {top1_pct:.2f}% (published {published}%)") |
| return res |
|
|
|
|
| def append_history(path, row: Dict[str, Any]) -> None: |
| p = Path(path) |
| ensure_dir(p.parent) |
| new = not p.exists() |
| with open(p, "a", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(row)) |
| if new: |
| w.writeheader() |
| w.writerow(row) |
|
|
|
|
| def train_backbone(cfg, model, loaders, device, paths, store_model, store_data, |
| sm: StageMachine, status: RunStatus, |
| interrupt: Optional[Interrupt] = None, |
| heartbeat_fn: Optional[Callable[[], None]] = None |
| ) -> Dict[str, Any]: |
| """The training loop. Checkpoints at epoch boundaries only. |
| |
| Mid-epoch resumption would require dataloader worker state, which is not |
| reliably serialisable. Epochs are ~45 s, so the granularity is fine. |
| """ |
| sci, rt = cfg["science"], cfg["runtime"] |
| train_loader, train_eval_loader, test_loader = loaders |
| amp = bool(rt.get("amp", True)) and device.type == "cuda" |
|
|
| optimizer = torch.optim.SGD(model.parameters(), lr=sci["lr"], |
| momentum=sci["momentum"], |
| weight_decay=sci["weight_decay"], nesterov=False) |
| scheduler = torch.optim.lr_scheduler.MultiStepLR( |
| optimizer, milestones=sci["milestones"], gamma=sci["gamma"]) |
| scaler = torch.amp.GradScaler("cuda", enabled=amp) |
|
|
| start_epoch, best, step, wall0, joules0 = 0, 0.0, 0, 0.0, 0.0 |
| st = load_checkpoint(paths["ckpt_last"], cfg, model, optimizer, scheduler, |
| scaler, device, status) |
| if st is None and store_model is not None: |
| p = store_model.download(f"runs/{sci['run_id']}/ckpt_last.pt", |
| paths["ckpt_last"]) |
| if p is not None: |
| st = load_checkpoint(paths["ckpt_last"], cfg, model, optimizer, |
| scheduler, scaler, device, status) |
| if st is not None: |
| start_epoch = st["epoch"] + 1 |
| best = st["best_metric"] |
| step = st["global_step"] |
| wall0 = st["wall_seconds"] |
| joules0 = st["energy_joules"] |
| resume_continuity_check(paths["history"], start_epoch, status) |
|
|
| energy = EnergyMonitor(paths["energy"]) |
| energy.start(resume_joules=joules0) |
|
|
| t_start = time.time() |
| nan_streak = 0 |
| el2n_scores = None |
| forget_counts = np.zeros(len(train_eval_loader.dataset), dtype=np.int32) |
| prev_correct = np.zeros(len(train_eval_loader.dataset), dtype=bool) |
|
|
| def _elapsed_h(): |
| return (wall0 + (time.time() - t_start)) / 3600.0 |
|
|
| gpu_ds = loaders[3] if len(loaders) > 3 else None |
| use_gpu_pipe = gpu_ds is not None |
| n_iter = (gpu_ds.n_batches(sci["batch_size"]) if use_gpu_pipe |
| else len(train_loader)) |
| aug_gen = None |
| if use_gpu_pipe and device.type == "cuda": |
| aug_gen = torch.Generator(device=device) |
| aug_gen.manual_seed(derive_seed(sci["seed"], "gpu_aug")) |
|
|
| for epoch in range(start_epoch, sci["epochs"]): |
| model.train() |
| run_loss, seen = 0.0, 0 |
| t_ep = time.time() |
| t_data = t_step = 0.0 |
| |
| |
| |
| |
| |
| |
| ep_correct = np.zeros(len(forget_counts), dtype=bool) |
| ep_seen = np.zeros(len(forget_counts), dtype=bool) |
|
|
| bar = make_progress(n_iter, f"ep {epoch:3d}/{sci['epochs']}", |
| enable=show_progress) |
| it = (gpu_ds.train_batches(sci["batch_size"], aug_gen) if use_gpu_pipe |
| else train_loader) |
| t_mark = time.time() |
| for batch in it: |
| x, y, si = batch |
| if not use_gpu_pipe: |
| x = x.to(device, non_blocking=True) |
| y = y.to(device, non_blocking=True) |
| t_data += time.time() - t_mark |
| t1 = time.time() |
|
|
| optimizer.zero_grad(set_to_none=True) |
| with torch.autocast("cuda", enabled=amp): |
| logits = model(x) |
| loss = F.cross_entropy(logits, y) |
| if not torch.isfinite(loss): |
| nan_streak += 1 |
| if nan_streak > 20: |
| bar.close() |
| raise RuntimeError( |
| f"non-finite loss for {nan_streak} consecutive steps at " |
| f"epoch {epoch} (lr={optimizer.param_groups[0]['lr']}, " |
| f"scale={scaler.get_scale() if amp else 'n/a'}). " |
| f"Set runtime.amp=False and resume.") |
| t_mark = time.time() |
| continue |
| nan_streak = 0 |
| scaler.scale(loss).backward() |
| scaler.step(optimizer) |
| scaler.update() |
|
|
| with torch.no_grad(): |
| ok = (logits.detach().argmax(1) == y) |
| si_np = (si.cpu().numpy() if torch.is_tensor(si) |
| else np.asarray(si)) |
| ep_correct[si_np] = ok.cpu().numpy() |
| ep_seen[si_np] = True |
|
|
| bs = y.numel() |
| run_loss += float(loss) * bs |
| seen += bs |
| step += 1 |
| t_step += time.time() - t1 |
| bar.update(1) |
| if step % 20 == 0: |
| bar.set_postfix_str(f"loss {run_loss/max(seen,1):.3f}") |
| t_mark = time.time() |
| bar.close() |
| scheduler.step() |
|
|
| t_train = time.time() - t_ep |
| t1 = time.time() |
| ev = evaluate(model, test_loader, device, amp) |
| t_eval = time.time() - t1 |
| train_loss = run_loss / max(seen, 1) |
| is_best = ev["top1"] > best |
| best = max(best, ev["top1"]) |
|
|
| |
| |
| flips = prev_correct & ~ep_correct & ep_seen |
| forget_counts += flips.astype(np.int32) |
| prev_correct = np.where(ep_seen, ep_correct, prev_correct) |
| np.save(paths["forget"], forget_counts) |
|
|
| t1 = time.time() |
| if epoch == sci["el2n_epoch"]: |
| |
| |
| el2n_scores, _, el2n_idx = el2n_and_preds(model, train_eval_loader, |
| device, amp) |
| order = np.argsort(el2n_idx) |
| np.save(paths["el2n"], el2n_scores[order]) |
| print(f" [EL2N] captured at epoch {epoch}") |
| t_extra = time.time() - t1 |
|
|
| t1 = time.time() |
| save_checkpoint(paths["ckpt_last"], cfg, model, optimizer, scheduler, |
| scaler, epoch, step, best, |
| wall0 + time.time() - t_start, energy.joules) |
| if is_best: |
| shutil.copy2(paths["ckpt_last"], paths["ckpt_best"]) |
| t_ckpt = time.time() - t1 |
| t_total = time.time() - t_ep |
| eta_h = (sci["epochs"] - epoch - 1) * t_total / 3600.0 |
|
|
| status.update(state="running", stage="train_backbone", epoch=epoch, |
| test_top1=ev["top1"], best=best) |
| if store_model is not None: |
| store_model.enqueue(paths["ckpt_last"], |
| f"runs/{sci['run_id']}/ckpt_last.pt") |
| if is_best: |
| store_model.enqueue(paths["ckpt_best"], |
| f"runs/{sci['run_id']}/ckpt_best.pt") |
| if store_data is not None: |
| for key, rp in (("history", "history.csv"), |
| ("energy", "energy.csv")): |
| store_data.enqueue(paths[key], f"logs/{sci['run_id']}/{rp}") |
|
|
| append_history(paths["history"], { |
| "epoch": epoch, "train_loss": f"{train_loss:.6f}", |
| "test_top1": f"{ev['top1']:.6f}", "test_top5": f"{ev['top5']:.6f}", |
| "test_loss": f"{ev['loss']:.6f}", |
| "lr": f"{optimizer.param_groups[0]['lr']:.6f}", |
| "scaler_scale": f"{scaler.get_scale() if amp else 0:.1f}", |
| "energy_j": f"{energy.joules:.1f}", |
| "sec_total": f"{t_total:.2f}", "sec_data": f"{t_data:.2f}", |
| "sec_compute": f"{t_step:.2f}", "sec_eval": f"{t_eval:.2f}", |
| "sec_extra": f"{t_extra:.2f}", "sec_ckpt": f"{t_ckpt:.2f}", |
| "wall_s": f"{wall0 + time.time() - t_start:.1f}", |
| "time_utc": now_iso(), |
| }) |
|
|
| print(f" ep {epoch:3d}/{sci['epochs']} loss {train_loss:.4f} " |
| f"top1 {ev['top1']*100:5.2f}% best {best*100:5.2f}% " |
| f"lr {optimizer.param_groups[0]['lr']:.4f} " |
| f"| {t_total:5.1f}s (data {t_data:4.1f} gpu {t_step:4.1f} " |
| f"eval {t_eval:4.1f} ckpt {t_ckpt:4.1f}) eta {eta_h:4.2f}h") |
| if epoch == start_epoch: |
| slow = "dataloader" if t_data > t_step else "gpu compute" |
| print(f" [TIMING] first epoch {t_total:.1f}s, dominated by {slow}. " |
| f"240 epochs -> ~{t_total*sci['epochs']/3600:.1f} h.") |
| if t_data > t_step and not use_gpu_pipe: |
| print(" [TIMING] set FAST_DATA=True to move augmentation onto " |
| "the GPU and remove the dataloader from the critical path.") |
|
|
| |
| |
| |
| if heartbeat_fn is not None and epoch % 10 == 0: |
| heartbeat_fn() |
|
|
| if disk_free_mb(rt["work_dir"]) < 2048: |
| status.anomaly("disk_low", f"{disk_free_mb(rt['work_dir'])} MB free") |
| if interrupt is not None and interrupt.stop_requested: |
| status.update(state="paused", stage="train_backbone", epoch=epoch) |
| raise KeyboardInterrupt("stop requested") |
| if _elapsed_h() > float(rt.get("session_budget_h", 8.5)): |
| status.update(state="paused", stage="train_backbone", epoch=epoch) |
| raise KeyboardInterrupt("session budget exhausted -- relaunch to resume") |
|
|
| energy.stop() |
| return {"best": best, "epochs_done": sci["epochs"], |
| "wall_seconds": wall0 + time.time() - t_start, |
| "energy_joules": energy.joules, |
| "el2n": paths["el2n"], "forget": paths["forget"]} |
|
|
|
|
| |
| |
| |
|
|
| @torch.no_grad() |
| def sweep_depth(model, heads: Dict[int, nn.Module], cached: Dict[str, Any], |
| block_idx: Sequence[int], device) -> Dict[str, np.ndarray]: |
| """Per-sample argmax / top1p / top2p at each depth configuration. |
| |
| Exit K comes from the model's own classifier, applied to the cached pooled |
| features, so preds[:, -1] is genuinely y*. |
| """ |
| K = len(block_idx) |
| n = cached["labels"].numel() |
| preds = np.zeros((n, K), dtype=np.int64) |
| t1 = np.zeros((n, K), dtype=np.float32) |
| t2 = np.zeros((n, K), dtype=np.float32) |
| for j, k in enumerate(block_idx): |
| X = cached[f"feat_{k}"].to(device) |
| outs = [] |
| for i in range(0, n, 1024): |
| xb = X[i:i + 1024] |
| logits = (model.fc(xb) if k == block_idx[-1] else heads[k](xb)) |
| outs.append(F.softmax(logits.float(), dim=1).cpu()) |
| p = torch.cat(outs) |
| top2 = p.topk(2, dim=1) |
| preds[:, j] = top2.indices[:, 0].numpy() |
| t1[:, j] = top2.values[:, 0].numpy() |
| t2[:, j] = top2.values[:, 1].numpy() |
| return {"preds": preds, "top1p": t1, "top2p": t2} |
|
|
|
|
| @torch.no_grad() |
| def sweep_resolution(model, loader, resolutions: Sequence[int], device, |
| mode: str = "native", amp: bool = True |
| ) -> Dict[str, np.ndarray]: |
| """mode='native' -- genuinely run at r, AdaptiveAvgPool2d handles the map. |
| mode='upsample' -- downsample to r then back to 32; network shape fixed. |
| |
| Native is the primary realisation: the cost is the FLOPs actually spent |
| rather than a counterfactual. Upsample is stored alongside as a robustness |
| column with its cost explicitly labelled idealised. |
| """ |
| model.eval() |
| K = len(resolutions) |
| P, T1, T2, ACC = [], [], [], [] |
| for j, r in enumerate(resolutions): |
| preds, t1, t2, corr, tot = [], [], [], 0, 0 |
| for x, y, _ in loader: |
| x = x.to(device, non_blocking=True) |
| if r != 32: |
| xr = F.interpolate(x, size=(r, r), mode="bilinear", |
| align_corners=False) |
| if mode == "upsample": |
| xr = F.interpolate(xr, size=(32, 32), mode="bilinear", |
| align_corners=False) |
| else: |
| xr = x |
| with torch.autocast("cuda", enabled=amp and device.type == "cuda"): |
| logits = model(xr) |
| p = F.softmax(logits.float(), dim=1) |
| top2 = p.topk(2, dim=1) |
| preds.append(top2.indices[:, 0].cpu()) |
| t1.append(top2.values[:, 0].cpu()) |
| t2.append(top2.values[:, 1].cpu()) |
| corr += int((top2.indices[:, 0].cpu() == y).sum()) |
| tot += y.numel() |
| P.append(torch.cat(preds).numpy()) |
| T1.append(torch.cat(t1).numpy()) |
| T2.append(torch.cat(t2).numpy()) |
| ACC.append(corr / max(tot, 1)) |
| print(f" r={r:2d}px ({mode:8s}) acc {ACC[-1]*100:5.2f}%") |
| return {"preds": np.stack(P, 1), "top1p": np.stack(T1, 1).astype(np.float32), |
| "top2p": np.stack(T2, 1).astype(np.float32), |
| "accuracy": np.array(ACC)} |
|
|
|
|
| def resolution_degeneracy_gate(acc: np.ndarray, msc_r: np.ndarray) -> Dict[str, Any]: |
| """This axis is not assumed to work. |
| |
| A model trained only at 32px, evaluated natively at 16px, is generalising |
| to a spatial-statistics regime it never saw. If accuracy collapses toward |
| chance then almost every sample is 'insufficient' at low r, MSC_r saturates |
| at 1.0, and the axis carries no per-sample signal. |
| """ |
| vals, counts = np.unique(msc_r[np.isfinite(msc_r)], return_counts=True) |
| max_mass = float(counts.max() / counts.sum()) if counts.size else 1.0 |
| res = {"acc_cheapest_pct": float(acc[0] * 100), |
| "max_level_mass": max_mass, |
| "criterion_1_acc_ge_25pct": bool(acc[0] >= 0.25), |
| "criterion_2_mass_le_70pct": bool(max_mass <= 0.70)} |
| res["informative"] = res["criterion_1_acc_ge_25pct"] and res["criterion_2_mass_le_70pct"] |
| if not res["informative"]: |
| print(f"[GATE] resolution axis DEGENERATE " |
| f"(acc@cheapest={res['acc_cheapest_pct']:.1f}%, " |
| f"max level mass={max_mass:.1%}). Excluded from the Q2 preview; " |
| f"Q1/Q3 gates are depth-axis quantities and are unaffected.") |
| return res |
|
|
|
|
| |
| |
| |
|
|
| @torch.no_grad() |
| def difficulty_battery(model, loader, device, block_idx, cached_train, |
| cached_eval, amp: bool = True) -> Dict[str, np.ndarray]: |
| """msp, margin, entropy, ce_loss, plus prediction depth via k-NN probes. |
| |
| el2n and forget_events are captured during training and merged by the |
| caller; they are only defined on training examples, and the test-set |
| variants are labelled *_testadapted. |
| |
| NOTE ON PREDICTION DEPTH: it is the earliest layer after which every |
| subsequent k-NN prediction agrees with the final one -- the same suffix |
| closure as MSC, with k-NN probes instead of linear heads. It is therefore |
| near-circular with the depth axis, and Delta-R^2 must be reported with and |
| without it (see 00_RESEARCH_PROTOCOL.md section 3, Q4). |
| """ |
| model.eval() |
| msp, margin, entropy, ce = [], [], [], [] |
| for x, y, _ in loader: |
| x = x.to(device, non_blocking=True) |
| y = y.to(device, non_blocking=True) |
| with torch.autocast("cuda", enabled=amp and device.type == "cuda"): |
| logits = model(x) |
| p = F.softmax(logits.float(), dim=1) |
| top2 = p.topk(2, dim=1).values |
| msp.append(top2[:, 0].cpu()) |
| margin.append((top2[:, 0] - top2[:, 1]).cpu()) |
| entropy.append((-(p * (p + 1e-12).log()).sum(1)).cpu()) |
| ce.append(F.cross_entropy(logits.float(), y, reduction="none").cpu()) |
|
|
| pd_ = _prediction_depth(cached_train, cached_eval, block_idx, device) |
| return {"msp": torch.cat(msp).numpy(), |
| "margin": torch.cat(margin).numpy(), |
| "entropy": torch.cat(entropy).numpy(), |
| "ce_loss": torch.cat(ce).numpy(), |
| "pred_depth": pd_} |
|
|
|
|
| def _prediction_depth(cached_train, cached_eval, block_idx, device, |
| k: int = 30, n_fit: int = 20000) -> np.ndarray: |
| """k-NN probe at each depth; depth = first index after which all |
| subsequent probe predictions agree with the final one.""" |
| y_tr = cached_train["labels"].numpy() |
| n_fit = min(n_fit, len(y_tr)) |
| rng = np.random.default_rng(0) |
| sel = rng.choice(len(y_tr), n_fit, replace=False) |
| n_eval = cached_eval["labels"].numel() |
| K = len(block_idx) |
| knn = np.zeros((n_eval, K), dtype=np.int64) |
|
|
| for j, b in enumerate(block_idx): |
| A = cached_train[f"feat_{b}"][sel].to(device).float() |
| A = A / (A.norm(dim=1, keepdim=True) + 1e-8) |
| yb = torch.as_tensor(y_tr[sel], device=device) |
| B = cached_eval[f"feat_{b}"].to(device).float() |
| B = B / (B.norm(dim=1, keepdim=True) + 1e-8) |
| out = [] |
| for i in range(0, n_eval, 512): |
| sim = B[i:i + 512] @ A.T |
| nn_idx = sim.topk(min(k, A.shape[0]), dim=1).indices |
| votes = yb[nn_idx] |
| out.append(torch.mode(votes, dim=1).values.cpu()) |
| knn[:, j] = torch.cat(out).numpy() |
|
|
| final = knn[:, -1] |
| agree = knn == final[:, None] |
| suffix = np.ones_like(agree) |
| suffix[:, -1] = agree[:, -1] |
| for j in range(K - 2, -1, -1): |
| suffix[:, j] = agree[:, j] & suffix[:, j + 1] |
| return np.where(suffix.any(1), suffix.argmax(1), K - 1).astype(np.int64) |
|
|
|
|
| |
| |
| |
|
|
| def emit_parquet(path, sample_idx, labels, depth, res_native, res_upsample, |
| battery: Dict[str, np.ndarray], resolutions: Sequence[int], |
| probe_k: Optional[Dict[str, np.ndarray]] = None, |
| meta: Optional[Dict[str, Any]] = None) -> Path: |
| """Row alignment is the single most dangerous bug in this project. |
| |
| A misalignment destroys real correlations or manufactures fake ones, and |
| nothing downstream looks broken. Every assertion here halts. |
| """ |
| import pandas as pd |
|
|
| sample_idx = np.asarray(sample_idx) |
| n = len(sample_idx) |
| assert np.array_equal(sample_idx, np.arange(n)), ( |
| f"sample_idx is not the canonical 0..{n-1} ordering. The evaluation " |
| f"loader must be shuffle=False, drop_last=False, sampler=None.") |
| for name, arr in (("labels", labels), ("depth.preds", depth["preds"]), |
| ("res_native.preds", res_native["preds"])): |
| assert len(arr) == n, f"{name} has {len(arr)} rows, expected {n}" |
|
|
| df = {"sample_idx": sample_idx.astype(np.int32), |
| "label": np.asarray(labels).astype(np.int16)} |
| K = depth["preds"].shape[1] |
| for j in range(K): |
| df[f"pred_d{j+1}"] = depth["preds"][:, j].astype(np.int16) |
| df[f"top1p_d{j+1}"] = depth["top1p"][:, j].astype(np.float32) |
| df[f"top2p_d{j+1}"] = depth["top2p"][:, j].astype(np.float32) |
| for j, r in enumerate(resolutions): |
| df[f"pred_r{r}"] = res_native["preds"][:, j].astype(np.int16) |
| df[f"top1p_r{r}"] = res_native["top1p"][:, j].astype(np.float32) |
| df[f"top2p_r{r}"] = res_native["top2p"][:, j].astype(np.float32) |
| if res_upsample is not None: |
| df[f"pred_ru{r}"] = res_upsample["preds"][:, j].astype(np.int16) |
| df[f"top1p_ru{r}"] = res_upsample["top1p"][:, j].astype(np.float32) |
| df[f"top2p_ru{r}"] = res_upsample["top2p"][:, j].astype(np.float32) |
| for k, v in battery.items(): |
| df[k] = np.asarray(v) |
| if probe_k is not None: |
| df["pred_probeK"] = probe_k["preds"].astype(np.int16) |
| df["top1p_probeK"] = probe_k["top1p"].astype(np.float32) |
| df["top2p_probeK"] = probe_k["top2p"].astype(np.float32) |
|
|
| out = pd.DataFrame(df) |
| assert out.isna().sum().sum() == 0, "NaNs in the per-sample table" |
|
|
| |
| |
| assert (out[f"pred_d{K}"].values == depth["preds"][:, -1]).all() |
|
|
| ensure_dir(Path(path).parent) |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| table = pa.Table.from_pandas(out, preserve_index=False) |
| if meta: |
| md = {k.encode(): json.dumps(v, default=str).encode() |
| for k, v in meta.items()} |
| table = table.replace_schema_metadata({**(table.schema.metadata or {}), **md}) |
| pq.write_table(table, path, compression="zstd") |
| print(f"[EMIT] {path} ({len(out)} rows x {len(out.columns)} cols)") |
| return Path(path) |
|
|
|
|
| def execute_run(run_id: str, BOOT: Dict[str, Any], token: str, |
| store_model: HFStore, store_data: HFStore, |
| registry: Optional["Registry"] = None, |
| *, smoke: bool = False, amp: bool = True, |
| deterministic: bool = True, |
| force_config_override: bool = False, |
| fast_data: bool = True, show_progress: bool = True, |
| session_budget_h: float = 8.5, |
| interrupt: Optional[Interrupt] = None, |
| work_dir: str = "/kaggle/working", |
| scratch_dir: str = "/kaggle/temp") -> Dict[str, Any]: |
| """Run ONE run_id end to end, stages 0-11, resuming wherever it left off. |
| |
| Idiom borrowed from E2AM: the library does one unit of work, the notebook |
| loops over units. That is what makes the account count a free parameter -- |
| one worker draining four runs sequentially and four workers doing one each |
| produce identical artifacts, because the runs share nothing. |
| |
| Safe to call repeatedly. Completed stages are skipped after a hash check. |
| """ |
| from huggingface_hub import hf_hub_download |
| import yaml |
|
|
| run_rec = next((r for r in BOOT["runs"] if r["run_id"] == run_id), None) |
| if run_rec is None: |
| raise ValueError(f"{run_id} not in the manifest") |
| arch, seed = run_rec["arch"], run_rec["seed"] |
| sd = BOOT["science_defaults"] |
|
|
| cfg = build_config( |
| run_id, arch, seed, |
| epochs=sd["epochs"], batch_size=sd["batch_size"], lr=sd["lr"], |
| momentum=sd["momentum"], weight_decay=sd["weight_decay"], |
| milestones=sd["milestones"], gamma=sd["gamma"], |
| exit_fractions=sd["exit_fractions"], resolutions=sd["resolutions"], |
| taus=sd["taus"], head_seeds=sd["head_seeds"], |
| head_epochs=sd["head_epochs"], head_lr=sd["head_lr"], |
| train_seen_n=sd["train_seen_n"], el2n_epoch=sd["el2n_epoch"], |
| deterministic=deterministic, smoke=smoke) |
| if smoke: |
| cfg["science"].update(epochs=2, milestones=[1], el2n_epoch=1, |
| head_epochs=2) |
| cfg["runtime"].update(amp=amp, work_dir=work_dir, scratch_dir=scratch_dir, |
| session_budget_h=session_budget_h, |
| fast_data=fast_data, show_progress=show_progress, |
| force_config_override=force_config_override) |
| cfg_hash = config_hash(cfg) |
| seed_info = set_all_seeds(seed, deterministic=deterministic) |
| cfg["runtime"]["deterministic"] = seed_info["deterministic"] |
|
|
| TAG = "_smoke/" if smoke else "" |
| local = ensure_dir(Path(work_dir) / "msc" / run_id) |
| scratch = ensure_dir(Path(scratch_dir) / "msc" / run_id) |
| P = { |
| "ckpt_last": local / "ckpt_last.pt", "ckpt_best": local / "ckpt_best.pt", |
| "history": local / "history.csv", "energy": local / "energy.csv", |
| "state": local / "STATE.json", "status": local / "STATUS.json", |
| "env": local / "env.json", "gate": local / "gate.json", |
| "config": local / "config.yaml", "cfghash": local / "config_hash.txt", |
| "bbhash": local / "backbone_hash.json", |
| "acc_curves": local / "accuracy_curves.json", |
| "el2n": scratch / "el2n.npy", "forget": scratch / "forget.npy", |
| "exc": local / "exceptions.jsonl", "stdout": local / "stdout.log", |
| "test_pq": local / "test.parquet", "seen_pq": local / "train_seen.parquet", |
| } |
| RP_M = f"runs/{TAG}{run_id}" |
| RP_L = f"logs/{TAG}{run_id}" |
|
|
| sm = StageMachine(P["state"], store_data, f"{RP_M}/STATE.json") |
| sm.pull() |
| status = RunStatus(P["status"], store_model, f"{RP_M}/STATUS.json", run_id) |
| status.update(state="running", stage=sm.first_incomplete(), |
| config_hash=cfg_hash) |
|
|
| def hb(): |
| if registry is not None: |
| registry.heartbeat(run_id) |
|
|
| def push_all(reason="manual"): |
| try: |
| status.data["state"] = "paused" |
| status.data["stop_reason"] = reason |
| atomic_write_json(P["status"], status.data) |
| for k, rp in (("ckpt_last", f"{RP_M}/ckpt_last.pt"), |
| ("ckpt_best", f"{RP_M}/ckpt_best.pt"), |
| ("status", f"{RP_M}/STATUS.json")): |
| store_model.enqueue(P[k], rp) |
| for k, rp in (("history", f"{RP_L}/history.csv"), |
| ("energy", f"{RP_L}/energy.csv"), |
| ("stdout", f"{RP_L}/stdout.log"), |
| ("exc", f"{RP_L}/exceptions.jsonl"), |
| ("env", f"{RP_L}/env.json"), |
| ("gate", f"{RP_L}/gate.json"), |
| ("bbhash", f"{RP_L}/backbone_hash.json"), |
| ("acc_curves", f"{RP_L}/accuracy_curves.json"), |
| ("state", f"{RP_M}/STATE.json"), |
| ("config", f"{RP_M}/config.yaml"), |
| ("cfghash", f"{RP_M}/config_hash.txt")): |
| store_data.enqueue(P[k], rp) |
| store_model.flush(120) |
| store_data.flush(120) |
| print(f"[PUSH] full push complete ({reason})") |
| except BaseException as e: |
| print(f"[PUSH] final push error ({reason}): {e}") |
|
|
| print("=" * 74) |
| print(f">>> {run_id} arch={arch} seed={seed} " |
| f"resume at stage: {sm.first_incomplete()}") |
| print("=" * 74) |
|
|
| device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") |
|
|
| |
| if not sm.done("env_capture"): |
| atomic_write_json(P["env"], hardware_report()) |
| atomic_write_text(P["config"], yaml.safe_dump(cfg, sort_keys=True)) |
| atomic_write_text(P["cfghash"], cfg_hash) |
| store_data.enqueue(P["env"], f"{RP_L}/env.json") |
| store_data.enqueue(P["config"], f"{RP_M}/config.yaml") |
| store_data.enqueue(P["cfghash"], f"{RP_M}/config_hash.txt") |
| sm.mark("env_capture") |
|
|
| |
| data_root = sm.state.get("notes", {}).get("data_root") |
| if not sm.done("dataset") or not data_root: |
| data_root = locate_cifar("cifar100", scratch_dir) |
| fp = dataset_fingerprint(data_root) |
| assert fp == BOOT["dataset_fingerprint"], ( |
| f"DATASET FINGERPRINT MISMATCH for {run_id}.\n" |
| f" bootstrap: {BOOT['dataset_fingerprint']}\n here: {fp}\n" |
| f"This run saw different data than NB00. Row alignment across runs " |
| f"would be void.") |
| sm.note("data_root", data_root) |
| sm.mark("dataset") |
| print("[DATA] fingerprint matches bootstrap") |
|
|
| |
| model = build_model(arch, 100).to(device) |
| block_idx = exit_block_indices(model, cfg["science"]["exit_fractions"]) |
| BUD = json.loads(Path(hf_hub_download( |
| BOOT["repo_data"], f"budgets/{arch}.json", repo_type="dataset", |
| token=token)).read_text()) |
| assert BUD["depth_block_idx"] == block_idx, \ |
| "budgets/{arch}.json disagrees with the model's exit indices" |
| if not sm.done("budgets"): |
| sm.mark("budgets") |
|
|
| loaders = build_loaders(cfg, data_root, device=device, |
| fast_gpu=cfg["runtime"].get("fast_data", True)) |
| train_loader, train_eval_loader, test_loader, _gpu_ds = loaders |
|
|
| |
| if not sm.done("train_backbone"): |
| status.update(stage="train_backbone") |
| try: |
| summary = train_backbone(cfg, model, loaders, device, P, |
| store_model, store_data, sm, status, |
| interrupt, heartbeat_fn=hb, |
| show_progress=cfg["runtime"].get( |
| "show_progress", True)) |
| sm.mark("train_backbone", best=str(summary["best"])) |
| except KeyboardInterrupt: |
| push_all("interrupt") |
| raise |
| except Exception as e: |
| log_exception(P["exc"], "train_backbone", |
| status.data.get("epoch", -1), e) |
| push_all("exception") |
| raise |
| else: |
| print("[SKIP] train_backbone already complete") |
| if not P["ckpt_last"].exists(): |
| store_model.download(f"{RP_M}/ckpt_last.pt", P["ckpt_last"]) |
| load_checkpoint(P["ckpt_last"], cfg, model, None, None, None, |
| device, status) |
| hb() |
|
|
| |
| ev = evaluate(model, test_loader, device, cfg["runtime"]["amp"]) |
| gate = accuracy_gate(arch, ev["top1"] * 100, P["gate"], smoke=smoke) |
| store_data.enqueue(P["gate"], f"{RP_L}/gate.json") |
| if not sm.done("accuracy_gate"): |
| sm.mark("accuracy_gate", top1=str(gate["top1_pct"])) |
|
|
| |
| model.eval() |
| for p_ in model.parameters(): |
| p_.requires_grad_(False) |
| bb_before = backbone_hash(model) |
|
|
| f_tr, f_te = scratch / "feat_train.pt", scratch / "feat_test.pt" |
| if not (f_tr.exists() and f_te.exists()): |
| cached_train = cache_pooled_features(model, train_eval_loader, |
| block_idx, device, f_tr) |
| cached_test = cache_pooled_features(model, test_loader, block_idx, |
| device, f_te) |
| else: |
| cached_train, cached_test = torch.load(f_tr), torch.load(f_te) |
| if not sm.done("cache_features"): |
| sm.mark("cache_features") |
|
|
| heads = {} |
| for hs in cfg["science"]["head_seeds"]: |
| heads[hs] = train_exit_heads(cached_train, cached_test, block_idx, 100, |
| head_seed=hs, |
| epochs=cfg["science"]["head_epochs"], |
| lr=cfg["science"]["head_lr"], device=device) |
| hp = local / f"exit_heads_s{hs}.pt" |
| torch.save({k: v.state_dict() for k, v in heads[hs].items()}, hp) |
| store_model.enqueue(hp, f"{RP_M}/exit_heads_s{hs}.pt") |
| print(f" head seed {hs}: {len(heads[hs])} probes") |
|
|
| bb_after = backbone_hash(model) |
| assert bb_after == bb_before, ( |
| "BACKBONE MOVED during head training. Each exit is now reading a " |
| "different network and the 'same model under reduced compute' " |
| "interpretation collapses.") |
| atomic_write_json(P["bbhash"], {"before": bb_before, "after": bb_after, |
| "unchanged": True}) |
| store_data.enqueue(P["bbhash"], f"{RP_L}/backbone_hash.json") |
| if not sm.done("train_heads"): |
| sm.mark("train_heads") |
| print("[FREEZE] backbone verified unchanged (params + buffers)") |
| hb() |
|
|
| |
| depth_sw = sweep_depth(model, heads[cfg["science"]["head_seeds"][0]], |
| cached_test, block_idx, device) |
| for hs in cfg["science"]["head_seeds"][1:]: |
| d = sweep_depth(model, heads[hs], cached_test, block_idx, device) |
| for nm, arr in (("preds", d["preds"]), ("t1", d["top1p"]), |
| ("t2", d["top2p"])): |
| np.save(scratch / f"depth_{nm}_s{hs}.npy", arr) |
| if not sm.done("sweep_depth"): |
| sm.mark("sweep_depth") |
|
|
| RES = cfg["science"]["resolutions"] |
| print("[SWEEP] resolution (native = PRIMARY):") |
| res_nat = sweep_resolution(model, test_loader, RES, device, "native", |
| cfg["runtime"]["amp"]) |
| print("[SWEEP] resolution (downsample-upsample = robustness):") |
| res_up = sweep_resolution(model, test_loader, RES, device, "upsample", |
| cfg["runtime"]["amp"]) |
|
|
| labels_np = cached_test["labels"].numpy() |
| depth_acc = [float((depth_sw["preds"][:, j] == labels_np).mean()) |
| for j in range(len(block_idx))] |
| atomic_write_json(P["acc_curves"], { |
| "depth": depth_acc, "resolution_native": res_nat["accuracy"].tolist(), |
| "resolution_upsample": res_up["accuracy"].tolist(), |
| "resolutions": list(RES)}) |
| store_data.enqueue(P["acc_curves"], f"{RP_L}/accuracy_curves.json") |
| assert abs(depth_acc[-1] - ev["top1"]) < 5e-4, ( |
| f"exit K accuracy {depth_acc[-1]:.4f} != backbone {ev['top1']:.4f}. " |
| f"Exit K must BE the model's own classifier.") |
| if not sm.done("sweep_resolution"): |
| sm.mark("sweep_resolution") |
| print(f"[SWEEP] depth accuracies: {[f'{a*100:.2f}%' for a in depth_acc]}") |
|
|
| battery = difficulty_battery(model, test_loader, device, block_idx, |
| cached_train, cached_test, cfg["runtime"]["amp"]) |
| el2n_te, corr_te, _ = el2n_and_preds(model, test_loader, device, |
| cfg["runtime"]["amp"]) |
| battery["el2n"] = el2n_te |
| battery["forget_events"] = (~corr_te).astype(np.int32) |
| if not sm.done("difficulty_battery"): |
| sm.mark("difficulty_battery") |
|
|
| |
| meta = {"run_id": run_id, "arch": arch, "seed": seed, |
| "config_hash": cfg_hash, "lib_version": __version__, |
| "dataset_fingerprint": BOOT["dataset_fingerprint"], |
| "rho_depth": BUD["rho_depth"], |
| "rho_resolution": BUD["rho_resolution"], |
| "deterministic": cfg["runtime"]["deterministic"], |
| "resolution_primary": "native", |
| "head_seed_for_depth_cols": cfg["science"]["head_seeds"][0]} |
| emit_parquet(P["test_pq"], cached_test["sample_idx"].numpy(), labels_np, |
| depth_sw, res_nat, res_up, battery, RES, meta=meta) |
| store_data.enqueue(P["test_pq"], f"per_sample/{TAG}{run_id}/test.parquet") |
| if not sm.done("emit_parquet"): |
| sm.mark("emit_parquet") |
|
|
| print("[GATE] resolution degeneracy:", |
| json.dumps(resolution_degeneracy_gate(res_nat["accuracy"], |
| np.array([0.0])))) |
|
|
| |
| push_all("finalise") |
| status.update(state="done", stage="finalise") |
| store_model.flush(300) |
| store_data.flush(300) |
| assert_inventory(run_id, arch, store_model, store_data, tag=TAG) |
| sm.mark("finalise", complete="true") |
| if registry is not None: |
| |
| |
| registry.complete(run_id, {"top1_pct": gate["top1_pct"], |
| "config_hash": cfg_hash, "smoke": smoke}) |
| print(f"<<< {run_id} COMPLETE top1={gate['top1_pct']:.2f}%\n") |
| return {"run_id": run_id, "top1_pct": gate["top1_pct"], |
| "depth_acc": depth_acc, "gate": gate} |
|
|
|
|
| ARTIFACT_INVENTORY = [ |
| ("config.yaml", "data", "runs/{tag}{run}/config.yaml"), |
| ("config_hash.txt", "data", "runs/{tag}{run}/config_hash.txt"), |
| ("env.json", "data", "logs/{tag}{run}/env.json"), |
| ("budgets.json", "data", "budgets/{arch}.json"), |
| ("ckpt_last.pt", "model", "runs/{tag}{run}/ckpt_last.pt"), |
| ("history.csv", "data", "logs/{tag}{run}/history.csv"), |
| ("energy.csv", "data", "logs/{tag}{run}/energy.csv"), |
| ("gate.json", "data", "logs/{tag}{run}/gate.json"), |
| ("backbone_hash.json", "data", "logs/{tag}{run}/backbone_hash.json"), |
| ("accuracy_curves.json", "data", "logs/{tag}{run}/accuracy_curves.json"), |
| ("test.parquet", "data", "per_sample/{tag}{run}/test.parquet"), |
| ("STATE.json", "data", "runs/{tag}{run}/STATE.json"), |
| ("STATUS.json", "model", "runs/{tag}{run}/STATUS.json"), |
| ("stdout.log", "data", "logs/{tag}{run}/stdout.log"), |
| ] |
|
|
|
|
| def assert_inventory(run_id: str, arch: str, store_model: HFStore, |
| store_data: HFStore, tag: str = "") -> Dict[str, Any]: |
| """We train once. The check that nothing was silently skipped has to be |
| mechanical, so `finalise` refuses to mark a run done without it.""" |
| files = {"model": store_model.list_files(), "data": store_data.list_files()} |
| missing = [] |
| for name, repo, tmpl in ARTIFACT_INVENTORY: |
| p = tmpl.format(run=run_id, arch=arch, tag=tag) |
| if p not in files[repo]: |
| missing.append(f"{repo}:{p}") |
| res = {"run_id": run_id, "checked": len(ARTIFACT_INVENTORY), |
| "missing": missing, "complete": not missing, "at": now_iso()} |
| if missing: |
| raise RuntimeError( |
| f"ARTIFACT INVENTORY INCOMPLETE for {run_id}. Missing:\n " + |
| "\n ".join(missing) + |
| "\nThe run is NOT done. Re-run the stage that produces each.") |
| print(f"[INVENTORY] all {len(ARTIFACT_INVENTORY)} artifacts present for {run_id}") |
| return res |
|
|
