mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
4.92 kB
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()