| """Guards for the staged ImageNet-v2 deployment protocol.""" |
|
|
| from __future__ import annotations |
|
|
| import importlib.util |
| import copy |
| import os |
| import subprocess |
| import sys |
| import tempfile |
| import unittest |
| from collections import Counter |
| from pathlib import Path |
| from unittest import mock |
|
|
| import yaml |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| PROTOCOL_PATH = ROOT / "configs/imagenet_v2_protocol.yaml" |
|
|
|
|
| def load_generator(): |
| path = ROOT / "scripts/generate_deploy.py" |
| spec = importlib.util.spec_from_file_location("gmnet_generate_deploy", path) |
| if spec is None or spec.loader is None: |
| raise RuntimeError(f"cannot import {path}") |
| module = importlib.util.module_from_spec(spec) |
| sys.modules[spec.name] = module |
| spec.loader.exec_module(module) |
| return module |
|
|
|
|
| class DeployProtocolTests(unittest.TestCase): |
| def test_exact_v2_matrix_and_initial_submission_gate(self) -> None: |
| protocol = yaml.safe_load(PROTOCOL_PATH.read_text(encoding="utf-8")) |
| tasks = protocol["tasks"] |
| self.assertEqual(len(tasks), 21) |
| self.assertEqual( |
| Counter(task["status"] for task in tasks), |
| {"ready": 1, "held": 18, "conditional": 2}, |
| ) |
| self.assertEqual( |
| [task["task_id"] for task in tasks if task["submission_allowed"]], |
| ["imv2_e0_s3_relu6_seed0"], |
| ) |
| confirmatory = [ |
| task for task in tasks if task["role"].startswith("confirmatory_") |
| ] |
| self.assertEqual( |
| Counter(task["gate"] for task in confirmatory), |
| { |
| "relu6_self": 3, |
| "relu_self": 3, |
| "smooth_clipped_self": 3, |
| "relu6_only": 3, |
| "no_gate": 3, |
| }, |
| ) |
| self.assertEqual( |
| protocol["run_root"], |
| "/nfs/ywang29/GmNet/runs/imagenet_v2", |
| ) |
| self.assertEqual(protocol["data_root"], "/tmp/gmnet_data/imagenet-1k") |
| self.assertEqual( |
| protocol["data_staging"]["source_archive_uri"], |
| "s3://snap-research-cv-code/ywang29/datasets/imagenet-1k/imagenet-1k.tar", |
| ) |
| self.assertEqual( |
| protocol["data_staging"]["destination_root"], |
| protocol["data_root"], |
| ) |
| self.assertEqual( |
| protocol["canonical_data_manifest"]["manifest_sha256"], |
| "bb70bc9f530db6bb24f70e648624b35281bfbc76a57775d589a2e0209dd98661", |
| ) |
| primary = protocol["primary_analysis"] |
| self.assertEqual( |
| primary["fixed_entry_gate"]["id"], |
| "h1_no_gate_material_loss", |
| ) |
| self.assertEqual( |
| [item["id"] for item in primary["downstream_holm_family"]["hypotheses"]], |
| [ |
| "h2_relu6_only_noninferiority", |
| "h3_relu_equivalence", |
| "h4_smooth_noninferiority", |
| ], |
| ) |
| self.assertEqual(protocol["primary_analysis"]["alpha"], 0.05) |
| smooth_seed0 = next( |
| task |
| for task in tasks |
| if task["task_id"] == "imv2_e3_s3_smooth_corrected_seed0" |
| ) |
| self.assertEqual( |
| smooth_seed0["external_prerequisites"], |
| ["smooth_local_pregate"], |
| ) |
| for task in tasks: |
| self.assertTrue(task["task_id"].startswith("imv2_")) |
| self.assertIn(task["phase"], protocol["phases"]) |
| self.assertTrue((ROOT / task["config_path"]).is_file()) |
|
|
| def test_generator_derives_dynamic_summary(self) -> None: |
| generator = load_generator() |
| protocol = generator.load_protocol() |
| tasks = generator.build_launch_tasks(protocol) |
| matrix = generator.build_task_matrix(protocol, tasks) |
| self.assertEqual(matrix["summary"]["launch_yaml_count"], len(tasks)) |
| self.assertEqual(matrix["summary"]["submission_allowed_count"], 1) |
| self.assertEqual( |
| matrix["code_manifest"], |
| "/nfs/ywang29/GmNet/journal_exp/configs/imagenet_v2_code_manifest.json", |
| ) |
| self.assertEqual( |
| matrix["canonical_data_manifest"]["manifest_sha256"], |
| "bb70bc9f530db6bb24f70e648624b35281bfbc76a57775d589a2e0209dd98661", |
| ) |
| self.assertEqual(matrix["data_root"], "/tmp/gmnet_data/imagenet-1k") |
| self.assertEqual( |
| matrix["data_staging"], |
| protocol["data_staging"], |
| ) |
| self.assertEqual( |
| matrix["summary"]["by_status"], |
| {"conditional": 2, "held": 18, "ready": 1}, |
| ) |
| for record in matrix["tasks"]: |
| self.assertIn("phase", record) |
| self.assertIn("role", record) |
| self.assertIn("depends_on", record) |
| self.assertIn("external_prerequisites", record) |
| self.assertIn("status", record) |
| self.assertIn("imv2", record["output_dir"]) |
| self.assertTrue(record["resolved_config"]["final_epoch_only"]) |
| self.assertTrue(record["resolved_config"]["raw_clip_zero_weight_decay"]) |
| self.assertEqual( |
| matrix["external_prerequisites"]["smooth_local_pregate"]["state"], |
| "passed", |
| ) |
| self.assertEqual( |
| matrix["external_prerequisites"]["smooth_local_pregate"]["evidence"], |
| "/nfs/ywang29/GmNet/local_results/imagenet_v2_pregate/CONCLUSIONS.md", |
| ) |
|
|
| def test_held_and_conditional_commands_default_to_deny(self) -> None: |
| generator = load_generator() |
| protocol = generator.load_protocol() |
| tasks = generator.build_launch_tasks(protocol) |
| invariants = generator.load_base_invariants() |
| data_root = protocol["data_root"] |
|
|
| ready = next(task for task in tasks if task.status == "ready") |
| ready_document = generator.build_launch_document(ready, invariants, data_root) |
| self.assertNotIn( |
| "GMNET_PROTOCOL_UNLOCK_TASK", ready_document["script"]["command"] |
| ) |
| self.assertIn( |
| "CODE_MANIFEST_PATH=configs/imagenet_v2_code_manifest.json", |
| ready_document["script"]["command"], |
| ) |
| self.assertIn( |
| "DATA_ROOT=/tmp/gmnet_data/imagenet-1k", |
| ready_document["script"]["command"], |
| ) |
| self.assertNotIn("DATA_ROOT=/s3-code", ready_document["script"]["command"]) |
| pre_run = ready_document["script"]["pre_run_event"] |
| self.assertIn( |
| "KEEP_ARCHIVE=0 bash ./scripts/stage_imagenet.sh full", |
| pre_run, |
| ) |
| self.assertLess( |
| pre_run.index("bash ./scripts/setup_env.sh"), |
| pre_run.index("bash ./scripts/stage_imagenet.sh full"), |
| ) |
|
|
| for task in tasks: |
| if task.status == "ready": |
| continue |
| with self.subTest(task=task.task_id): |
| document = generator.build_launch_document(task, invariants, data_root) |
| expected = f"GMNET_PROTOCOL_UNLOCK_TASK={task.task_id}" |
| self.assertIn(expected, document["script"]["pre_run_event"]) |
| self.assertIn(expected, document["script"]["command"]) |
| self.assertIn("exit 64", document["script"]["command"]) |
|
|
| held = next(task for task in tasks if task.status == "held") |
| held_document = generator.build_launch_document(held, invariants, data_root) |
| environment = os.environ.copy() |
| environment.pop("GMNET_PROTOCOL_UNLOCK_TASK", None) |
| denied = subprocess.run( |
| ["bash", "-c", held_document["script"]["command"]], |
| check=False, |
| capture_output=True, |
| text=True, |
| env=environment, |
| ) |
| self.assertEqual(denied.returncode, 64) |
| self.assertIn("Protocol guard denied", denied.stderr) |
|
|
| def test_resolved_config_semantics_reject_protocol_drift(self) -> None: |
| generator = load_generator() |
| protocol = generator.load_protocol() |
| tasks = generator.build_launch_tasks(protocol) |
| smooth = next( |
| task |
| for task in tasks |
| if task.task_id == "imv2_e3_s3_smooth_corrected_seed0" |
| ) |
| resolved = generator.load_resolved_config(ROOT / smooth.config_path) |
| generator.validate_resolved_config(smooth, resolved) |
|
|
| drifted = copy.deepcopy(resolved) |
| drifted["model"]["smooth_clip_trainable"] = False |
| with self.assertRaisesRegex(ValueError, "smooth_clip_trainable"): |
| generator.validate_resolved_config(smooth, drifted) |
|
|
| drifted = copy.deepcopy(resolved) |
| drifted["optimizer"]["no_weight_decay_patterns"] = [] |
| with self.assertRaisesRegex(ValueError, "raw_clip"): |
| generator.validate_resolved_config(smooth, drifted) |
|
|
| def test_unknown_external_prerequisite_is_rejected(self) -> None: |
| generator = load_generator() |
| protocol = generator.load_protocol() |
| protocol["tasks"] = copy.deepcopy(protocol["tasks"]) |
| smooth = next( |
| task |
| for task in protocol["tasks"] |
| if task["task_id"] == "imv2_e3_s3_smooth_corrected_seed0" |
| ) |
| smooth["external_prerequisites"] = ["not_registered"] |
| with self.assertRaisesRegex(ValueError, "unknown external prerequisites"): |
| generator.build_launch_tasks(protocol) |
|
|
| def test_stale_cleanup_removes_only_generated_yaml(self) -> None: |
| generator = load_generator() |
| with tempfile.TemporaryDirectory() as directory: |
| root = Path(directory) |
| expected = root / "expected.yaml" |
| stale = root / "stale.yaml" |
| manual = root / "manual.yaml" |
| stale.write_text(generator.GENERATED_HEADER + "value: 2\n") |
| manual.write_text("value: keep\n") |
| with mock.patch.object(generator, "DEPLOY_ROOT", root): |
| removed = generator.write_files( |
| {expected: generator.GENERATED_HEADER + "value: 1\n"} |
| ) |
| self.assertEqual(removed, [stale]) |
| self.assertFalse(stale.exists()) |
| self.assertTrue(expected.is_file()) |
| self.assertTrue(manual.is_file()) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
