| """Unit tests for paper GmNet variants and gate ablations.""" |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import unittest |
|
|
| import torch |
|
|
| from gmnet.models import ( |
| GATE_INTERVENTION_SEED_STRIDE, |
| GMNET_CONFIGS, |
| GmNet, |
| GmNetBlock, |
| SmoothClippedSelfGate, |
| build_gate, |
| gmnet_s1, |
| gmnet_s2, |
| gmnet_s3, |
| gmnet_s4, |
| ) |
|
|
|
|
| class GateTests(unittest.TestCase): |
| def test_required_gate_semantics(self) -> None: |
| x = torch.tensor([[[[-2.0, -0.5, 0.5, 2.0, 8.0]]]]) |
|
|
| torch.testing.assert_close( |
| build_gate("relu6_self", 1)(x), x * torch.clamp(x, 0.0, 6.0) |
| ) |
| torch.testing.assert_close( |
| build_gate("relu6_only", 1)(x), torch.clamp(x, 0.0, 6.0) |
| ) |
| torch.testing.assert_close(build_gate("relu_self", 1)(x), x * torch.relu(x)) |
| torch.testing.assert_close( |
| build_gate("gelu_self", 1)(x), x * torch.nn.functional.gelu(x) |
| ) |
| torch.testing.assert_close(build_gate("identity", 1)(x), x.square()) |
| torch.testing.assert_close(build_gate("no_gate", 1)(x), x) |
|
|
| def test_smooth_clipped_gate_is_static_learnable_and_bounded(self) -> None: |
| gate = SmoothClippedSelfGate(3, init_clip=6.0, beta=10.0) |
| x = torch.linspace(-10.0, 12.0, 23).view(1, 1, 1, 23).expand(2, 3, 4, 23) |
| values = gate.gate_value(x) |
|
|
| self.assertEqual(gate.raw_clip.shape, (1, 3, 1, 1)) |
| self.assertTrue(torch.all(gate.clip_value > 0)) |
| self.assertGreaterEqual(float(values.detach().min()), -1e-6) |
| self.assertLessEqual( |
| float(values.detach().max()), float(gate.clip_value.detach().max()) + 1e-5 |
| ) |
|
|
| loss = gate(x).square().mean() |
| loss.backward() |
| self.assertIsNotNone(gate.raw_clip.grad) |
| self.assertTrue(torch.isfinite(gate.raw_clip.grad).all()) |
| self.assertGreater(float(gate.raw_clip.grad.abs().sum()), 0.0) |
|
|
| def test_smooth_clipped_gate_supports_fixed_persistent_clip(self) -> None: |
| gate = SmoothClippedSelfGate( |
| 3, init_clip=6.0, beta=10.0, per_channel=False, trainable=False |
| ) |
| self.assertIsNone(gate.raw_clip) |
| self.assertEqual(sum(parameter.numel() for parameter in gate.parameters()), 0) |
| torch.testing.assert_close(gate.clip_value, torch.tensor([[[[6.0]]]])) |
| self.assertIn("fixed_clip", gate.state_dict()) |
|
|
| restored = SmoothClippedSelfGate( |
| 3, init_clip=6.0, beta=10.0, per_channel=False, trainable=False |
| ) |
| restored.load_state_dict(gate.state_dict(), strict=True) |
| x = torch.randn(2, 3, 4, 4) |
| torch.testing.assert_close(restored(x), gate(x)) |
|
|
| def test_smooth_checkpoint_topology_is_rebuilt_from_trainable_config(self) -> None: |
| common = { |
| "embed_dims": (8, 16, 24, 32), |
| "depths": (1, 1, 1, 1), |
| "mlp_ratios": (1, 1, 1, 1), |
| "stem_dim": 8, |
| "num_classes": 5, |
| "gate_type": "smooth_clipped_self", |
| "smooth_clip_per_channel": False, |
| } |
| for trainable, state_suffix in ((True, "raw_clip"), (False, "fixed_clip")): |
| with self.subTest(trainable=trainable): |
| config = {**common, "smooth_clip_trainable": trainable} |
| source = GmNet(**config) |
| checkpoint = { |
| "config": copy.deepcopy(config), |
| "model": copy.deepcopy(source.state_dict()), |
| } |
| restored = GmNet(**checkpoint["config"]) |
| restored.load_state_dict(checkpoint["model"], strict=True) |
| gate_keys = [ |
| key |
| for key in checkpoint["model"] |
| if key.endswith(("raw_clip", "fixed_clip")) |
| ] |
| self.assertTrue(gate_keys) |
| self.assertTrue(all(key.endswith(state_suffix) for key in gate_keys)) |
|
|
| def test_invalid_gate_is_rejected(self) -> None: |
| with self.assertRaisesRegex(ValueError, "unknown gate_type"): |
| build_gate("not_a_gate", 8) |
|
|
| def test_stop_gradient_preserves_forward_and_changes_gate_gradient(self) -> None: |
| baseline = build_gate("relu6_self", 3) |
| stopped = build_gate("relu6_self", 3, gate_intervention="stop_gradient") |
| baseline_input = torch.tensor([0.5, 2.0, 4.0]).view(1, 3, 1, 1) |
| baseline_input.requires_grad_() |
| stopped_input = baseline_input.detach().clone().requires_grad_() |
|
|
| baseline_output = baseline(baseline_input) |
| stopped_output = stopped(stopped_input) |
| self.assertTrue(torch.equal(baseline_output, stopped_output)) |
|
|
| baseline_output.sum().backward() |
| stopped_output.sum().backward() |
| self.assertTrue(torch.isfinite(stopped_input.grad).all()) |
| self.assertFalse(torch.equal(baseline_input.grad, stopped_input.grad)) |
| torch.testing.assert_close( |
| stopped_input.grad, torch.tensor([0.5, 2.0, 4.0]).view(1, 3, 1, 1) |
| ) |
|
|
| def test_channel_derangement_is_deterministic_and_preserves_multiset(self) -> None: |
| first = build_gate( |
| "relu6_self", |
| 8, |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| second = build_gate( |
| "relu6_self", |
| 8, |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| permutation = first.gate_permutation |
| self.assertIsNotNone(permutation) |
| assert permutation is not None |
| self.assertTrue(torch.equal(permutation, second.gate_permutation)) |
| self.assertTrue( |
| torch.equal(permutation.sort().values, torch.arange(permutation.numel())) |
| ) |
| self.assertTrue(torch.all(permutation != torch.arange(permutation.numel()))) |
|
|
| x = torch.arange(48, dtype=torch.float32).reshape(2, 8, 1, 3) |
| permuted = first.gate_input(x) |
| torch.testing.assert_close(permuted.sort(dim=1).values, x.sort(dim=1).values) |
| torch.testing.assert_close(first(x), x * torch.clamp(permuted, 0.0, 6.0)) |
|
|
| def test_channel_derangement_does_not_consume_global_rng(self) -> None: |
| torch.manual_seed(73) |
| expected = torch.rand(7) |
| torch.manual_seed(73) |
| build_gate( |
| "relu6_self", |
| 8, |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| actual = torch.rand(7) |
| self.assertTrue(torch.equal(actual, expected)) |
|
|
| def test_batch_derangement_is_seeded_bijective_and_rng_free(self) -> None: |
| gate = build_gate( |
| "relu6_self", |
| 3, |
| gate_intervention="batch_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| x = torch.arange(60, dtype=torch.float32).reshape(5, 3, 2, 2) |
| shift = 1 + 41_041 % 4 |
| expected_input = x.roll(shifts=-shift, dims=0) |
|
|
| torch.manual_seed(919) |
| expected_rng = torch.rand(8) |
| torch.manual_seed(919) |
| actual_input = gate.gate_input(x) |
| actual_rng = torch.rand(8) |
|
|
| self.assertEqual(gate.batch_derangement_shift(5), shift) |
| self.assertTrue(torch.equal(actual_input, expected_input)) |
| self.assertTrue(torch.equal(actual_rng, expected_rng)) |
| self.assertTrue( |
| torch.equal( |
| actual_input.flatten(1).sort(dim=0).values, |
| x.flatten(1).sort(dim=0).values, |
| ) |
| ) |
| with self.assertRaisesRegex(ValueError, "at least two samples"): |
| gate.gate_input(x[:1]) |
|
|
| def test_stop_gradient_channel_derangement_matches_forward_only(self) -> None: |
| channel = build_gate( |
| "relu6_self", |
| 4, |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| combined = build_gate( |
| "relu6_self", |
| 4, |
| gate_intervention="stop_gradient_channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| self.assertTrue(torch.equal(channel.gate_permutation, combined.gate_permutation)) |
| channel_input = ( |
| torch.tensor([0.5, 1.5, 2.5, 3.5]) |
| .reshape(1, 4, 1, 1) |
| .requires_grad_() |
| ) |
| combined_input = channel_input.detach().clone().requires_grad_() |
|
|
| channel_output = channel(channel_input) |
| combined_output = combined(combined_input) |
| self.assertTrue(torch.equal(channel_output, combined_output)) |
| channel_output.sum().backward() |
| combined_output.sum().backward() |
|
|
| self.assertFalse(torch.equal(channel_input.grad, combined_input.grad)) |
| torch.testing.assert_close( |
| combined_input.grad, |
| torch.clamp( |
| combined.gate_input(combined_input.detach()), min=0.0, max=6.0 |
| ), |
| ) |
|
|
| def test_intervention_rejects_non_self_gate_and_invalid_mode(self) -> None: |
| for gate_type in ("relu6_only", "no_gate"): |
| with self.subTest(gate_type=gate_type): |
| with self.assertRaisesRegex(ValueError, "multiplicative self-gate"): |
| build_gate(gate_type, 8, gate_intervention="channel_derangement") |
| with self.assertRaisesRegex(ValueError, "unknown gate_intervention"): |
| build_gate("relu6_self", 8, gate_intervention="not_an_intervention") |
|
|
|
|
| class GmNetTests(unittest.TestCase): |
| FACTORIES = { |
| "s1": gmnet_s1, |
| "s2": gmnet_s2, |
| "s3": gmnet_s3, |
| "s4": gmnet_s4, |
| } |
| EXPECTED_PARAMETERS = { |
| "s1": 3_661_600, |
| "s2": 6_206_296, |
| "s3": 7_791_544, |
| "s4": 17_061_460, |
| } |
|
|
| def test_paper_variant_topology_parameters_and_forward(self) -> None: |
| for name, factory in self.FACTORIES.items(): |
| with self.subTest(variant=name): |
| model = factory().eval() |
| config = GMNET_CONFIGS[name] |
| self.assertEqual(model.embed_dims, config.embed_dims) |
| self.assertEqual(model.depths, config.depths) |
| self.assertEqual(model.mlp_ratios, config.mlp_ratios) |
| self.assertEqual( |
| tuple(len(stage) - 1 for stage in model.stages), config.depths |
| ) |
|
|
| parameter_count = sum( |
| parameter.numel() for parameter in model.parameters() |
| ) |
| self.assertEqual(parameter_count, self.EXPECTED_PARAMETERS[name]) |
|
|
| model.reset_classifier(17) |
| with torch.inference_mode(): |
| output = model(torch.randn(1, 3, 64, 64)) |
| self.assertEqual(output.shape, (1, 17)) |
| self.assertTrue(torch.isfinite(output).all()) |
|
|
| def test_all_gate_types_run_in_a_model(self) -> None: |
| gate_types = ( |
| "relu6_self", |
| "relu6_only", |
| "relu_self", |
| "gelu_self", |
| "identity", |
| "no_gate", |
| "smooth_clipped_self", |
| ) |
| for gate_type in gate_types: |
| with self.subTest(gate_type=gate_type): |
| model = GmNet( |
| embed_dims=(8, 16, 24, 32), |
| depths=(1, 1, 1, 1), |
| mlp_ratios=(1, 1, 1, 1), |
| stem_dim=8, |
| num_classes=5, |
| gate_type=gate_type, |
| ).eval() |
| with torch.inference_mode(): |
| output = model(torch.randn(1, 3, 64, 64)) |
| self.assertEqual(output.shape, (1, 5)) |
|
|
| def test_experiment_registry_gate_aliases(self) -> None: |
| aliases = { |
| "relu6": "relu6_self", |
| "activation_only": "relu6_only", |
| "relu6_activation_only": "relu6_only", |
| "relu": "relu_self", |
| "gelu": "gelu_self", |
| "smooth_clipped_static": "smooth_clipped_self", |
| } |
| x = torch.randn(2, 3, 4, 4) |
| for alias, canonical in aliases.items(): |
| with self.subTest(alias=alias): |
| torch.testing.assert_close( |
| build_gate(alias, 3)(x), build_gate(canonical, 3)(x) |
| ) |
|
|
| def test_stage_specific_gates_and_feature_head(self) -> None: |
| model = GmNet( |
| embed_dims=(8, 16, 24, 32), |
| depths=(1, 1, 1, 1), |
| mlp_ratios=(1, 1, 1, 1), |
| stem_dim=8, |
| num_classes=0, |
| gate_type=("no_gate", "relu_self", "gelu_self", "smooth_clipped_self"), |
| ).eval() |
| self.assertEqual( |
| model.gate_types, |
| ("no_gate", "relu_self", "gelu_self", "smooth_clipped_self"), |
| ) |
| with torch.inference_mode(): |
| output = model(torch.randn(2, 3, 64, 64)) |
| self.assertEqual(output.shape, (2, 32)) |
|
|
| model.reset_classifier(7) |
| with torch.inference_mode(): |
| output = model(torch.randn(2, 3, 64, 64)) |
| self.assertEqual(output.shape, (2, 7)) |
|
|
| @staticmethod |
| def _tiny_model(**kwargs: object) -> GmNet: |
| return GmNet( |
| embed_dims=(8, 16, 24, 32), |
| depths=(1, 1, 1, 1), |
| mlp_ratios=(2, 2, 2, 2), |
| stem_dim=8, |
| num_classes=5, |
| **kwargs, |
| ) |
|
|
| def test_default_and_explicit_baseline_are_bitwise_compatible(self) -> None: |
| torch.manual_seed(991) |
| default = self._tiny_model().eval() |
| torch.manual_seed(991) |
| explicit = self._tiny_model( |
| gate_intervention="baseline", gate_intervention_seed=41_041 |
| ).eval() |
|
|
| self.assertEqual(default.state_dict().keys(), explicit.state_dict().keys()) |
| for key, value in default.state_dict().items(): |
| self.assertTrue(torch.equal(value, explicit.state_dict()[key]), key) |
| x = torch.randn(2, 3, 64, 64) |
| with torch.inference_mode(): |
| self.assertTrue(torch.equal(default(x), explicit(x))) |
|
|
| def test_interventions_preserve_parameters_and_checkpoint_schema(self) -> None: |
| models = { |
| mode: self._tiny_model( |
| gate_intervention=mode, gate_intervention_seed=41_041 |
| ) |
| for mode in ( |
| "baseline", |
| "stop_gradient", |
| "channel_derangement", |
| "batch_derangement", |
| "stop_gradient_channel_derangement", |
| ) |
| } |
| baseline = models["baseline"] |
| expected_keys = tuple(baseline.state_dict()) |
| expected_parameters = sum(p.numel() for p in baseline.parameters()) |
| for mode, model in models.items(): |
| with self.subTest(mode=mode): |
| self.assertEqual(tuple(model.state_dict()), expected_keys) |
| self.assertEqual( |
| sum(p.numel() for p in model.parameters()), expected_parameters |
| ) |
| model.load_state_dict(baseline.state_dict(), strict=True) |
| self.assertFalse( |
| any("gate_permutation" in key for key in model.state_dict()) |
| ) |
|
|
| def test_channel_derangement_uses_per_block_seed_and_auditable_metadata( |
| self, |
| ) -> None: |
| model = gmnet_s3( |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| metadata = model.gate_intervention_metadata() |
| blocks = [ |
| module for module in model.modules() if isinstance(module, GmNetBlock) |
| ] |
| self.assertEqual(len(metadata), 17) |
| self.assertEqual(len(blocks), 17) |
| for index, (block, item) in enumerate(zip(blocks, metadata, strict=True)): |
| with self.subTest(block=index): |
| expected_seed = 41_041 + index * GATE_INTERVENTION_SEED_STRIDE |
| self.assertEqual(block.gate_intervention_seed, expected_seed) |
| self.assertEqual(item["seed"], expected_seed) |
| self.assertEqual(item["global_block_index"], index) |
| self.assertEqual(item["mode"], "channel_derangement") |
| self.assertEqual(item["fixed_points"], 0) |
| self.assertIs(item["is_bijection"], True) |
| self.assertEqual(len(item["permutation_sha256"]), 64) |
| self.assertEqual( |
| item["permutation_hash_encoding"], |
| "little_endian_int64_c_order", |
| ) |
| self.assertIn( |
| "gate_permutation", block.gate._non_persistent_buffers_set |
| ) |
|
|
| def test_combined_intervention_reuses_every_channel_permutation(self) -> None: |
| channel = gmnet_s3( |
| gate_intervention="channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| combined = gmnet_s3( |
| gate_intervention="stop_gradient_channel_derangement", |
| gate_intervention_seed=41_041, |
| ) |
| channel_rows = channel.gate_intervention_metadata() |
| combined_rows = combined.gate_intervention_metadata() |
| self.assertEqual(len(channel_rows), 17) |
| self.assertEqual(len(combined_rows), 17) |
| for channel_row, combined_row in zip( |
| channel_rows, combined_rows, strict=True |
| ): |
| self.assertEqual( |
| channel_row["permutation_sha256"], |
| combined_row["permutation_sha256"], |
| ) |
| self.assertIs(combined_row["stops_gate_gradient"], True) |
| self.assertIs(combined_row["channel_derangement"], True) |
| self.assertIs(combined_row["batch_derangement"], False) |
|
|
| def test_stop_gradient_model_has_finite_parameter_gradients(self) -> None: |
| model = self._tiny_model(gate_intervention="stop_gradient") |
| loss = model(torch.randn(2, 3, 64, 64)).square().mean() |
| loss.backward() |
| gradients = [ |
| parameter.grad |
| for parameter in model.parameters() |
| if parameter.requires_grad |
| ] |
| self.assertTrue(all(gradient is not None for gradient in gradients)) |
| self.assertTrue(all(torch.isfinite(gradient).all() for gradient in gradients)) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
