"""Generated-data core quickstart: admission, calibration, deep updates, restore. This is an executable API example and engineering check, not a benchmark. """ from __future__ import annotations import argparse import hashlib import json from pathlib import Path import sys import torch from torch.nn import functional as F CORE = Path(__file__).resolve().parents[1] / "src" sys.path.insert(0, str(CORE)) from avenyra_omega import FrozenFeatures, OrthogonalMemory, ResidualMLP, BoundedResidualClassifier from avenyra_omega.calibration import acquisition_scores from avenyra_omega.renewal import FreshRiskController def old_distribution(seed, count_per_class=256): generator = torch.Generator().manual_seed(seed) y = torch.arange(2).repeat_interleave(count_per_class) x = .015 * torch.randn(len(y), 8, generator=generator) x[:, 0] += torch.where(y == 0, -torch.ones(len(y)), torch.ones(len(y))) * 3. return x, y def construct(): features = FrozenFeatures(8, kind="linear", seed=7000) memory = OrthogonalMemory(features.feature_dim, 3, feature_signature=features.signature, failure_budget=.05) raw = ResidualMLP(8, 3, width=24) return features, memory, raw def tree_equal(a, b): if torch.is_tensor(a): return torch.equal(a, b) if isinstance(a, dict): return a.keys() == b.keys() and all(tree_equal(a[k], b[k]) for k in a) if isinstance(a, (list, tuple)): return len(a) == len(b) and all(tree_equal(x, y) for x, y in zip(a, b)) return a == b def run(output): output = Path(output) output.mkdir(parents=True, exist_ok=False) torch.set_num_threads(1) torch.manual_seed(7000) features, memory, raw = construct() fit_x, fit_y = old_distribution(7001, 128) # Acquisition reference, center and feature map are fixed using ONLY this fit split. proposal = memory.ridge_proposal(features(fit_x), F.one_hot(fit_y, 3).double(), ridge=.001) admission = memory.admit(proposal, residual_radius=0., label="initial old-class center") assert admission["status"] == "ACCEPTED" calibration_x, calibration_y = old_distribution(7002, 256) certificates = [] for cls in (0, 1): z = features(calibration_x[calibration_y == cls]) reference_logits, power = memory.center_and_power(z) scores = acquisition_scores(reference_logits, reference_logits, power) certificate = memory.calibrate_acquisition(scores, task=cls, risk=.05, failure_probability=.025, independent_calibration=True, stratum=f"old_class{cls}", distribution="independent generated old-class Gaussian", reference_id="fit-only initial center") if certificate.status != "CONDITIONAL": raise RuntimeError("This example did not obtain a positive radius; failed attempt remains registered") memory.add_certificate(certificate) certificates.append(certificate.to_dict()) assert len(memory.calibration_attempts) == 2 and memory.check_confidence_budget() == .05 model = BoundedResidualClassifier(features, memory, raw, radius=0.) radius = model.set_certified_radius(.6) assert radius > 0 signature = features.validate_signature() # Every raw-network parameter is mutable; there is no projected-head-only update. assert all(p.requires_grad for p in raw.parameters()) initial_raw = {name: p.detach().clone() for name, p in raw.named_parameters()} generator = torch.Generator().manual_seed(7004) new_x = .03 * torch.randn(192, 8, generator=generator) new_x[:, 1] += 3. new_y = torch.full((len(new_x),), 2, dtype=torch.long) optimizer = torch.optim.Adam(raw.parameters(), lr=.02) losses = [] max_residual_bound_excess = -float("inf") for _ in range(40): optimizer.zero_grad(set_to_none=True) prediction, parts = model(new_x, return_parts=True) excess = float((parts["residual"].detach().norm(dim=1) - radius * parts["power"]).max()) max_residual_bound_excess = max(max_residual_bound_excess, excess) loss = F.cross_entropy(prediction, new_y) loss.backward() optimizer.step() losses.append(float(loss.detach())) assert max_residual_bound_excess <= 1e-12 assert features.validate_signature() == signature motion = {name: float((p.detach() - initial_raw[name]).norm()) for name, p in raw.named_parameters()} assert all(value > 0 for value in motion.values()) evaluation_x, evaluation_y = old_distribution(7003, 512) with torch.no_grad(): reference = memory.center_and_power(features(evaluation_x))[0].argmax(1) final_old = model(evaluation_x).argmax(1) old_accuracy = float((final_old == evaluation_y).double().mean()) old_reference_flip = float((final_old != reference).double().mean()) new_accuracy = float((model(new_x).argmax(1) == new_y).double().mean()) probe = torch.cat((evaluation_x[:32], new_x[:32])) before_restore = model(probe).clone() checkpoint = output / "full_checkpoint.pt" torch.save({"model": model.state_dict(), "optimizer": optimizer.state_dict(), "torch_rng_state": torch.get_rng_state(), "configuration": { "feature_kind": "linear", "input_dim": 8, "classes": 3, "width": 24, "fit_seed": 7001, "calibration_seed": 7002, "evaluation_seed": 7003, "new_fit_seed": 7004}}, checkpoint) restored_features, restored_memory, restored_raw = construct() restored = BoundedResidualClassifier(restored_features, restored_memory, restored_raw, radius=0.) loaded = torch.load(checkpoint, map_location="cpu", weights_only=True) restored.load_state_dict(loaded["model"]) restored_optimizer = torch.optim.Adam(restored.raw_model.parameters(), lr=.02) restored_optimizer.load_state_dict(loaded["optimizer"]) torch.set_rng_state(loaded["torch_rng_state"]) assert torch.equal(before_restore, restored(probe).detach()) assert tree_equal(optimizer.state_dict(), restored_optimizer.state_dict()) assert len(restored.memory.calibration_attempts) == 2 and len(restored.memory.certificates) == 2 # A matched extra step verifies that restored optimizer moments are operational. for candidate, opt in ((model, optimizer), (restored, restored_optimizer)): opt.zero_grad(set_to_none=True) F.cross_entropy(candidate(new_x), new_y).backward() opt.step() assert torch.equal(model(probe).detach(), restored(probe).detach()) # Separate fresh-checkpoint controller: labels, not old-teacher predictions. fresh = FreshRiskController(failure_budget=.05) fresh_events = [] for attempt, invert in enumerate((False, True)): evidence_x, evidence_y = old_distribution(8001 + attempt, 256) # Both candidate functions are predeclared before their evidence is drawn. predicted = (evidence_x[:, 0] > 0).long() if invert: predicted = 1 - predicted blocks = {} for cls in (0, 1): mask = evidence_y == cls blocks[f"class{cls}"] = {"errors": (predicted[mask] != evidence_y[mask]).numpy(), "source_ids": (torch.arange(256) + 100000 + attempt * 1000 + cls * 256).numpy()} event = fresh.evaluate_candidate(blocks, candidate_id="good_fixed_rule" if not invert else "inverted_fixed_rule", risk=.05, failure_probability=.01, fixed_before_evidence=True, required_strata=blocks.keys()) fresh_events.append(event) assert [event["status"] for event in fresh_events] == ["ACCEPTED", "REFUSED"] assert fresh.deployed_candidate == "good_fixed_rule" and len(fresh.used_ids) == 1024 fresh_copy = FreshRiskController(failure_budget=.05) fresh_copy.load_state_dict(fresh.state_dict()) assert fresh_copy.state_dict() == fresh.state_dict() (output / "fresh_controller.json").write_text(json.dumps(fresh.state_dict(), indent=2) + "\n") report = {"scope": "Generated-data API and engineering example; no benchmark superiority or exact floating-point population guarantee", "initial_admission": admission, "registered_calibration_attempts": len(memory.calibration_attempts), "confidence_spent": memory.check_confidence_budget(), "certificates": certificates, "configured_residual_radius": radius, "all_raw_parameters_trainable": True, "raw_parameter_motion_by_tensor": motion, "frozen_feature_signature_unchanged": True, "new_fit_loss_first": losses[0], "new_fit_loss_last": losses[-1], "new_fit_accuracy": new_accuracy, "independent_old_evaluation_accuracy": old_accuracy, "independent_old_reference_flip_rate": old_reference_flip, "max_observed_residual_bound_excess": max_residual_bound_excess, "checkpoint_prediction_roundtrip_exact": True, "optimizer_roundtrip_exact": True, "matched_resume_step_exact": True, "checkpoint_file_bytes": checkpoint.stat().st_size, "fresh_controller_statuses": [event["status"] for event in fresh_events], "fresh_controller_deployed_after_refusal": fresh.deployed_candidate, "fresh_controller_confidence_spent_including_refusal": fresh.confidence_spent, "fresh_controller_unique_evidence_sources": len(fresh.used_ids), "fresh_controller_checkpoint_roundtrip_exact": True, "source_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), "core_source_sha256": {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted((CORE / "avenyra_omega").glob("*.py"))}} (output / "report.json").write_text(json.dumps(report, indent=2) + "\n") return report if __name__ == "__main__": parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--output", type=Path, required=True) args = parser.parse_args() print(json.dumps(run(args.output), indent=2))