import unittest import torch import numpy as np import random import os # Import canonical implementations (to be replaced with the actual import path) from canonical import ARC as CanonicalARC, CrossAttn as CanonicalCrossAttn # Import generated implementations (to be replaced with the actual import path) from model import ARC as GeneratedARC, CrossAttn as GeneratedCrossAttn # Dummy wrapper to simulate 'h' input for ARC.forward class DummyH: def __init__(self, x_list): self.x_list = x_list def set_seed(): seed = 2025 random.seed(seed) os.environ['PYTHONHASHSEED'] = str(seed) np.random.seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.manual_seed(seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True class TestGeneralistGADEquivalence(unittest.TestCase): def setUp(self): torch.manual_seed(42) np.random.seed(42) self.num_nodes = 8 self.in_feats = 6 self.h_feats = 4 self.num_layers = 2 self.num_hops = 3 self.embedding_dim = self.h_feats * self.num_hops # Simulate multi-hop propagated features (e.g., [X^[0], X^[1], ..., X^[L]]) self.x_list = [torch.randn(self.num_nodes, self.in_feats) for _ in range(self.num_hops + 1)] self.h_obj = DummyH([x.clone() for x in self.x_list]) # Embedding matrices for CrossAttn self.X = torch.randn(self.num_nodes, self.embedding_dim) self.y = torch.tensor([0, 0, 1, 1, 0, 0, 1, 0], dtype=torch.long) self.num_prompt = 2 # For test_score self.prompt_mask = torch.tensor([True, True, False, False, False, True, False, False]) def test_arc_forward_equivalence(self): # Set up both canonical and generated modules identically set_seed() canonical_model = CanonicalARC( in_feats=self.in_feats, h_feats=self.h_feats, num_layers=self.num_layers, num_hops=self.num_hops ) set_seed() generated_model = GeneratedARC( in_feats=self.in_feats, h_feats=self.h_feats, num_layers=self.num_layers, num_hops=self.num_hops ) canonical_out = canonical_model.forward(self.h_obj) generated_out = generated_model.forward(self.h_obj) self.assertEqual(canonical_out.shape, generated_out.shape, "Mismatch in output shape of ARC.forward") self.assertEqual(type(canonical_out), type(generated_out), "Mismatch in output type of ARC.forward") # If deterministic, check closeness torch.testing.assert_close(canonical_out, generated_out, rtol=1e-5, atol=1e-7) def test_cross_attn_equivalence(self): set_seed() canonical_model = CanonicalCrossAttn(self.embedding_dim) set_seed() generated_model = GeneratedCrossAttn(self.embedding_dim) # Query and support embeddings query_X = self.X[:4] support_X = self.X[4:] canonical_attn = canonical_model.cross_attention(query_X, support_X) generated_attn = generated_model.cross_attention(query_X, support_X) self.assertEqual(canonical_attn.shape, generated_attn.shape, "Mismatch in cross_attention output shape") torch.testing.assert_close(canonical_attn, generated_attn, rtol=1e-5, atol=1e-7) def test_cross_attn_train_loss_equivalence(self): # Set seed for random sampling in both modules set_seed() canonical_model = CanonicalCrossAttn(self.embedding_dim) set_seed() generated_model = GeneratedCrossAttn(self.embedding_dim) set_seed() canonical_loss = canonical_model.get_train_loss(self.X, self.y, self.num_prompt) # Reset seed for identical random sampling set_seed() generated_loss = generated_model.get_train_loss(self.X, self.y, self.num_prompt) self.assertIsInstance(canonical_loss, torch.Tensor) self.assertIsInstance(generated_loss, torch.Tensor) self.assertAlmostEqual(float(canonical_loss), float(generated_loss), places=6, msg="Mismatch in training loss values between canonical and generated") def test_cross_attn_test_score_equivalence(self): set_seed() canonical_model = CanonicalCrossAttn(self.embedding_dim) set_seed() generated_model = GeneratedCrossAttn(self.embedding_dim) canonical_score = canonical_model.get_test_score(self.X, self.prompt_mask, self.y) generated_score = generated_model.get_test_score(self.X, self.prompt_mask, self.y) self.assertEqual(canonical_score.shape, generated_score.shape, "Mismatch in test_score output shape") torch.testing.assert_close(canonical_score, generated_score, rtol=1e-5, atol=1e-7) if __name__ == "__main__": unittest.main()