Download annotations/annotation_30/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 4.92 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_30/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_30/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_30/test.py
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() | |