Download annotations/annotation_41/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 11.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_41/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_41/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_41/test.py
11.3 kB
| import unittest | |
| import torch | |
| import torch.nn as nn | |
| import dgl | |
| import random | |
| import numpy as np | |
| # Assume the user's provided code is in a file named 'canonical.py' | |
| # A generated version would be in 'generation.py' | |
| # For this demonstration, we use the canonical code as the generated one to ensure tests pass. | |
| from hete.canonical import contrastive_loss as canonical_contrastive_loss | |
| from hete.canonical import EMA as CanonicalEMA | |
| from hete.canonical import update_moving_average as canonical_update_moving_average | |
| from hete.canonical import set_requires_grad as canonical_set_requires_grad | |
| from hete.canonical import Model as CanonicalGraphACLModel | |
| from hete.model import contrastive_loss as generated_contrastive_loss | |
| from hete.model import EMA as GeneratedEMA | |
| from hete.model import update_moving_average as generated_update_moving_average | |
| from hete.model import set_requires_grad as generated_set_requires_grad | |
| from hete.model import Model as GeneratedGraphACLModel | |
| class TestFunctionalEquivalence(unittest.TestCase): | |
| """ | |
| Test suite to verify that the generated model implementation is functionally | |
| identical to the canonical implementation. | |
| """ | |
| def setUp(self): | |
| """ | |
| Set up common parameters and data for all tests. | |
| This method runs before each test function. | |
| """ | |
| # Set a fixed seed for reproducibility | |
| torch.manual_seed(42) | |
| # Define small, representative dimensions and parameters | |
| self.in_dim = 16 | |
| self.hidden_dim = 8 | |
| self.layer_num = 2 | |
| self.num_mlp_layers = 2 | |
| self.sample_size = 5 | |
| self.tau = 0.5 | |
| self.lambda_loss = 1.0 | |
| self.ema_decay = 0.99 | |
| # --- Create Sample Input Data --- | |
| self.num_nodes = 10 | |
| self.num_edges = 20 | |
| self.batch_size = 4 | |
| # Model inputs | |
| self.graph = dgl.rand_graph(self.num_nodes, self.num_edges) | |
| self.graph = dgl.add_self_loop(self.graph) # Add self-loops to avoid 0-in-degree nodes | |
| self.features = torch.randn(self.num_nodes, self.in_dim) | |
| self.neighbor_dict = {i: self.graph.successors(i).tolist() for i in range(self.num_nodes)} | |
| self.batch_indices = torch.randperm(self.num_nodes)[:self.batch_size] | |
| # Loss function inputs | |
| self.p_emd = torch.randn(self.batch_size, 1, self.hidden_dim) | |
| self.v_emd = torch.randn(self.batch_size, 1, self.hidden_dim) | |
| self.u_neighbors = torch.randn(self.batch_size, self.sample_size, self.hidden_dim) | |
| self.v_neg_samples = torch.randn(self.batch_size, self.sample_size, self.hidden_dim) | |
| def test_contrastive_loss(self): | |
| """ | |
| Test Instruction 1: Verify the contrastive loss function. | |
| """ | |
| canonical_loss = canonical_contrastive_loss(self.p_emd, self.v_emd, self.u_neighbors, self.v_neg_samples, self.tau, self.lambda_loss) | |
| generated_loss = generated_contrastive_loss(self.p_emd, self.v_emd, self.u_neighbors, self.v_neg_samples, self.tau, self.lambda_loss) | |
| torch.testing.assert_close(canonical_loss, generated_loss, msg="Contrastive loss values are not equivalent.") | |
| def test_ema_class(self): | |
| """ | |
| Test Instructions 2 & 3: Verify the EMA class initialization and update method. | |
| """ | |
| # Test initialization | |
| canonical_ema = CanonicalEMA(self.ema_decay) | |
| generated_ema = GeneratedEMA(self.ema_decay) | |
| self.assertEqual(canonical_ema.beta, generated_ema.beta, "EMA decay_rate mismatch.") | |
| # Test update_average method | |
| old_val = torch.randn(5) | |
| new_val = torch.randn(5) | |
| canonical_updated = canonical_ema.update_average(old_val, new_val) | |
| generated_updated = generated_ema.update_average(old_val, new_val) | |
| torch.testing.assert_close(canonical_updated, generated_updated, msg="EMA updated values are not equivalent.") | |
| def test_standalone_ema_update_function(self): | |
| """ | |
| Test Instruction 4: Verify the standalone EMA update utility function. | |
| """ | |
| # Create two simple models with identical structure | |
| model1 = nn.Linear(10, 2) | |
| model2 = nn.Linear(10, 2) | |
| model2.load_state_dict(model1.state_dict()) # Ensure they start different from target | |
| target_model = nn.Linear(10, 2) | |
| canonical_ema = CanonicalEMA(self.ema_decay) | |
| generated_ema = GeneratedEMA(self.ema_decay) | |
| # Update a copy of the target model using the canonical function | |
| target_model_canon = nn.Linear(10, 2) | |
| target_model_canon.load_state_dict(target_model.state_dict()) | |
| canonical_update_moving_average(canonical_ema, target_model_canon, model1) | |
| # Update another copy using the generated function | |
| target_model_gen = nn.Linear(10, 2) | |
| target_model_gen.load_state_dict(target_model.state_dict()) | |
| generated_update_moving_average(generated_ema, target_model_gen, model1) | |
| for p_canon, p_gen in zip(target_model_canon.parameters(), target_model_gen.parameters()): | |
| torch.testing.assert_close(p_canon.data, p_gen.data, msg="Standalone EMA update resulted in different model parameters.") | |
| def test_set_requires_grad(self): | |
| """ | |
| Test Instruction 5: Verify the gradient computation control function. | |
| """ | |
| # Canonical | |
| c_model = nn.Linear(10, 2) | |
| canonical_set_requires_grad(c_model, False) | |
| for p in c_model.parameters(): | |
| self.assertFalse(p.requires_grad) | |
| canonical_set_requires_grad(c_model, True) | |
| for p in c_model.parameters(): | |
| self.assertTrue(p.requires_grad) | |
| # Generated | |
| g_model = nn.Linear(10, 2) | |
| generated_set_requires_grad(g_model, False) | |
| for p in g_model.parameters(): | |
| self.assertFalse(p.requires_grad) | |
| generated_set_requires_grad(g_model, True) | |
| for p in g_model.parameters(): | |
| self.assertTrue(p.requires_grad) | |
| def test_graphacl_model_initialization(self): | |
| """ | |
| Test Instruction 6: Verify the GraphACLModel initialization. | |
| """ | |
| torch.manual_seed(42) | |
| canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay, num_MLP=self.num_mlp_layers) | |
| torch.manual_seed(42) | |
| generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay, num_MLP=self.num_mlp_layers) | |
| # Compare parameters of online encoders | |
| for p_canon, p_gen in zip(canonical_model.graphconv1.parameters(), generated_model.graphconv1.parameters()): | |
| torch.testing.assert_close(p_canon, p_gen, msg="Online encoder conv1 weights mismatch on init.") | |
| # Compare parameters of target encoders (should be identical copies) | |
| for p_canon, p_gen in zip(canonical_model.target_graphconv1.parameters(), generated_model.target_graphconv1.parameters()): | |
| torch.testing.assert_close(p_canon, p_gen, msg="Target encoder conv1 weights mismatch on init.") | |
| # Compare parameters of projectors | |
| for p_canon, p_gen in zip(canonical_model.projector.parameters(), generated_model.projector.parameters()): | |
| torch.testing.assert_close(p_canon, p_gen, msg="Projector weights mismatch on init.") | |
| def test_graphacl_ema_update_method(self): | |
| """ | |
| Test Instruction 7: Verify the model's internal EMA update method. | |
| """ | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) | |
| generated_model.load_state_dict(canonical_model.state_dict()) | |
| # Perform one forward pass to change online weights (requires grad) | |
| optimizer_canon = torch.optim.Adam(canonical_model.parameters(), lr=0.01) | |
| optimizer_gen = torch.optim.Adam(generated_model.parameters(), lr=0.01) | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| loss_canon, _ = canonical_model(self.graph, self.features, self.neighbor_dict, 'cpu') | |
| loss_canon.backward() | |
| optimizer_canon.step() | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| loss_gen, _ = generated_model(self.graph, self.features, self.neighbor_dict, 'cpu') | |
| loss_gen.backward() | |
| optimizer_gen.step() | |
| # Now apply the EMA update | |
| canonical_model.update_moving_average() | |
| generated_model.update_moving_average() | |
| for p_canon, p_gen in zip(canonical_model.target_graphconv1.parameters(), generated_model.target_graphconv1.parameters()): | |
| torch.testing.assert_close(p_canon.data, p_gen.data, msg="Model's EMA update method resulted in different target parameters.") | |
| def test_graphacl_model_forward_pass(self): | |
| """ | |
| Test Instruction 8: Verify the full model forward pass. | |
| Note: The canonical implementation's `sample_neighbors` has non-deterministic elements | |
| (random.sample, np.random.choice). We set seeds to ensure the same samples are drawn. | |
| """ | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| canonical_model = CanonicalGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| generated_model = GeneratedGraphACLModel(self.in_dim, self.hidden_dim, self.layer_num, self.sample_size, self.tau, moving_average_decay=self.ema_decay) | |
| generated_model.load_state_dict(canonical_model.state_dict()) | |
| # Execute forward pass for both models | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| canonical_loss, canonical_embs = canonical_model(self.graph, self.features, self.neighbor_dict, 'cpu') | |
| torch.manual_seed(42) | |
| random.seed(42) | |
| np.random.seed(42) | |
| generated_loss, generated_embs = generated_model(self.graph, self.features, self.neighbor_dict, 'cpu') | |
| # Compare outputs | |
| torch.testing.assert_close(canonical_loss, generated_loss, msg="Forward pass returned different loss values.") | |
| torch.testing.assert_close(canonical_embs, generated_embs, msg="Forward pass returned different online embeddings.") | |
| if __name__ == '__main__': | |
| # Prepare a dummy generation.py to make imports work | |
| # with open("model.py", "w") as f: | |
| # with open("canonical.py", "r") as c: | |
| # f.write(c.read()) | |
| unittest.main(argv=['first-arg-is-ignored'], exit=False) | |